Back Room Front Room 2

MANAGING COMPLEXITY OF
ENTERPRISE INFORMATION SYSTEMS
Leszek A. Maciaszek
Macquarie University, Sydney, Australia
Email: leszek@ics.mq.edu.au
Keywords: Software complexity, software architectures, object dependency management.
Abstract: The complexity of modern software is not that much in the size of systems as it is in the “wires” – in the
linkages and communication paths between system components. The inter-component linkages create
dependencies between distributed components that are difficult to understand and manage. The difficulty is
inflated by the fact that components are frequently developed and managed by separate teams and by
various component providers.
This paper identifies main issues for successful management of complexity in large software projects. It
uses the holon hypothesis to explain that all complex systems of a stable but evolvable character display
hierarchic organization. The paper makes it clear that a complexity-aware architectural design paves the
way for developing supportable systems. It makes it also clear that unless implementation is designconformant
and complexity-assured, the initial good intents may still result in an unsupportable system.
Without rigorous project management, supported by tools able to compute and visualize complexity metrics,
contemporary large software production risks delivering unsupportable systems..
1 INTRODUCTION
Complexity management and dependency
management are two sides of the same coin.
Dependency management is an integral part of
architectural design. Architectural design takes a
proactive approach to managing dependencies in
software. It does so by deciding early in the process
on hierarchical layers of software components and
on dependency firewalls between the layers. This is
a forward-engineering approach – from design to
implementation. The aim is to deliver a software
design that minimizes dependencies by imposing an
architectural solution on programmers.
The outcomes of the proactive approach to
managing dependencies must be monitored by the
reactive approach that aims at measuring
dependencies in implemented software. This is a
reverse-engineering approach – from
implementation to design. The implementation may
or may not conform to the desired architectural
design. If it does not, the aim is to compare the
metric values in the software with the values that the
desired architecture would have delivered. The
troublesome dependencies need to be pinpointed and
addressed.
This paper refers to four fundamental issues in
design of enterprise information systems:
I. Seruca et al. (eds.), Enterprise Information Systems VI,
© 2006 S pringer. Printed in the Netherlands.
30
30–36.
(1) component design that reduces complexity and
makes component dependencies traceable in
program and database structures, (2) dependencyminimizing
design of the architectural layers
housing application components and reaching to
database and web services, (3) round-trip
engineering with metrics to evaluate system
complexity, and (4) identification and specification
of design principles and patterns targeting
minimization of complexity in enterprise
information systems.
Prior to describing our approach for managing
complexity in systems, the paper explains the
background for it – software holons. The concept of
holon (from the Greek word: holos = whole and with
the suffix on suggesting a part, as in neutron or
proton) was introduced by Koestler (1967) and it has
since been used by various branches of science
ranging from biology to communication theory, as
observed by the theory originator in Koestler (1980).