Developing Maintainable Systems –
Roundtrip Engineering with Metrics
Leszek A.
Maciaszek, Bruc Lee Liong
To
be presented by:
_____________________________
Leszek A. Maciaszek
Macquarie
University
Department
of Computing
Sydney,
NSW 2109, Australia
tel:
+61 2 98509519
fax:
+61 2 98509551
email:
leszek@ics.mq.edu.au
courier:
E6A-319, Herring Road, North Ryde
http://www.comp.mq.edu.au/~leszek
The tutorial
explains fundamental conditions for building maintainable object-oriented
client/server systems. It starts by explaining the principles and premises of
object technology as the driving force of modern software production. It then
concentrates on the importance of architectural design as the foundation to
implementing maintainable systems. A maintainable system is one that delivers
desired functionality and satisfies other requirements with understandable and
scalable architecture that minimizes object dependencies.
Apart from a
recommendation for an architectural design, the software development process
presented in the tutorial involves roundtrip engineering of maintainability
metrics. The initial metrics (class dependencies) are computed from UML design
models. Object dependencies that are hard to discover from design models (such
as message and event dependencies) are measured from the application code and
reverse-engineered to UML diagrams.
The tutorial
proposes how to harness the complexity of large design models, improve software
architectures, facilitate software readability, promote layered structuring of
objects. The metrics are used as a project management tool to validate if the
implementation conforms to the architectural design.
The reality of software production is full of
examples of failed projects, exceeded deadlines and budgets, faulty solutions,
unmaintainable systems, etc. Surveys show that almost three out of four
software projects fail in one or more of the above aspects. The paramount
questions are: What causes software projects to fail? What are the symptoms of
project problems and how to address them? How to model, design and program
successful system solutions? How to construct systems that are understandable,
maintainable and scalable? The last question is the main subject of this
tutorial.
This tutorial addresses two fundamental issues in design
and implementation of enterprise information systems: (1) architecture-driven
design that facilitates system maintainability, and (2) the use of metrics to
validate if the implementation conforms to the chosen architectural framework.
The former is a forward-engineering issue - from design to implementation. The
aim is to deliver a software design that minimizes object dependencies and
imposes the architectural solution on programmers. The latter is largely a
reverse-engineering issue – 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 must be
pinpointed and addressed.
We classify object dependencies into: (1) class
dependencies, (2) message dependencies, (3) event dependencies, and (4)
inheritance dependencies. The idea is to uncover all object dependencies in a
system, make them explicit and measure them with a set of metrics. An
intermediate goal is to minimize the dependencies through skilful system
design. The ultimate goal is to provide a method and process for system design
that produces maintainable solutions.
The
tutorial proposes an architectural framework to harness the complexity of large
design models, improve system design, facilitate software readability and
promote layered structuring of objects. The
framework divides system into manageable modules by using both horizontal
layers and vertical partitions. Each partition (package) may be layered and
each layer may be partitioned. Horizontal
layers establish a fixed structure between packages – an invariant for all
iterations of the incremental development process. While a horizontal structure
defines the rules of the game, vertical structures inside packages define the
course of the game. A horizontal structure defines the permitted moves;
vertical structures leave room for relatively flexible strategies how to decide
on the choice of the actual move.
The proposed
architectural framework is called PCDF (Maciaszek et al., 2004). PCDF
consists of four main layers – presentation, control, domain, and foundation. PCDF evolved from an earlier
framework called BCED – boundary, control, entity, dbinterface (Maciaszek,
2001). The principles of PCDF are similar to other popular layering schemes.
Ø MACIASZEK, L.A. (2001): Requirements Analysis and
System Design. Developing Information Systems with UML, Addison-Wesley
London, 378p. (2nd edition in 2004}
Ø MACIASZEK, L.A. LIONG,
B.L. and BILLS, S. (2004): Practical Software Engineering, An Iterative
Case-Study Approach to Enterprise Information Systems Development,
Addison-Wesley London, ~600p. (to be published in early 2004)
To appreciate the punch
line of the tutorial, the participants need to have a moderate experience in
developing information systems. A
basic understanding of object technology and software development environments
will be advantageous. The instructor will
gauge the technical background of the audience at the beginning of the tutorial
and will accordingly adjust the technical difficulty of the presented material.
This tutorial is aimed
at wide audience of researchers, students and IT professionals. An ideal
participant is a student/researcher in database or software engineering, or a
developer of enterprise database applications. Practitioners most likely to benefit from the tutorial include
system designers, programmers, software architects, business and system
analysts, project leaders and managers, web and content developers, reviewers,
testers, quality assurance managers and industry trainers. For practitioners
already using UML, Java/C++ and relational databases on software projects, this
tutorial can serve as a validation of their software development practices and
as a source of development ideas and directions.
The tutorial is lecture-style presentation. The
presentation includes examples and case studies, and – subject to time
availability and audience preferences – software/tool demonstrations.
1 What
is a maintainable system? Architectural Layers and Dependency Management.
Architectural Metrics and Patterns.
1.1 Architectural
Modules (Classes and Packages).
1.2 Package
and Layer Dependencies.
1.3 Class
Dependencies.
1.5 Method
Dependencies and Delegation.
1.6 Using
Interfaces to Break Circular Dependencies.
1.7 Event
Processing.
1.8 Acquaintance.
2 Architectural Frameworks for System
Maintainability.
2.1 Model-View-Controller.
2.2
Presentation-Control-Domain-Foundation.
2.3
Other frameworks.
3. Round-Trip Engineering with Metrics.
The presenter is an Associate Professor of Computing at Macquarie University, Sydney, Australia. Originally from Poland, Leszek has worked and consulted interchangeably in academia and industry in countries on four continents. He moved to Australia in 1985.
Leszek’s professional life has been crossing academia and
industry. Apart from teaching in universities, Leszek has been a regular
trainer to IT industry. He has an extensive consulting experience, frequently
to large international corporations. His research has been in databases,
object-oriented technology, software engineering, and development of
large-scale enterprise information systems.
Leszek
published in excess of hundred publications, including a number of textbooks
and reference books. Main past titles are: "Database
Design and Implementation" (Prentice Hall, 1990) and "Requirements Analysis and System
Design. Developing Information Systems with UML" (Addison Wesley,
2001). The latter has been translated to several languages and the second
edition will be published in mid 2004. He is also the lead author of a
forthcoming software engineering title Practical Software Engineering, An
Iterative Case-Study Approach to Enterprise Information Systems Development,
Addison-Wesley (2004).