Developing Maintainable Systems –
Roundtrip Engineering with Metrics
Leszek A. Maciaszek, Bruc Lee Liong
To be presented by:
Leszek A. Maciaszek
Department of Computing
Sydney, NSW 2109, Australia
tel: +61 2 98509519
fax: +61 2 98509551
courier: E6A-319, Herring Road, North Ryde
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.
2 Architectural Frameworks for System Maintainability.
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).