Carola Lilienthal

Architectural Complexity of Large-Scale Software Systems

Today companies apply software systems with more than 14 million Lines of Code (LOC), which are still maintainable and expandable in spite of their size. On the other hand, you will find smaller software systems (≫200,000 LOC), which can either only be adapted with considerable effort, or which cannot be adapted at all. Why are some software systems fraught with maintenance problems while others remain manageable? Based on twenty-four industrial case studies on object-oriented Java projects, this paper identifies aspects of architectural complexity and describes which route should be taken to keep the architectural complexity of large-scale software systems controllable. In this context it becomes clear that in every case the architectural style is pivotal in determining whether the software system will be maintainable over a longer period and thus prevent software erosion.

Educating non-programmers to flexible, communicative software engineers in a 10 month training program

Financial services companies which heavily depend on IT, still face a shortage of well-educated software engineers. Of the two principal ways to react to this, either by training employees who are already IT-professionals or by introducing talented and interested nonprogrammers to software engineering, the latter was chosen by a large insurance company in Hamburg, Germany. This experience report points out why and how this approach, realized as a trainee program with a well-balanced mix of both technical and soft skills, could be as successful as it eventually turned out to be.

External validation of a metrics-based quality assessment of the JWAM Framework

Product metrics allow for an efficient way to get feedback about the quality of an existing software system. Beside the internal validation of metrics, i.e. their examination with respect to measurement theory, the external validation is important to examine the value of results based on metrics analysis. In this paper, a well-defined process to get a metrics-based quality assessment is applied to the Java Framework JWAM. For the external validation its results were analysed by the JWAM development team: Most aspects were valuable to them and the findings were classified as either completely new, confirming rough knowledge, or well known. Additionally, a second process walkthrough for the new JWAM-version showed that many detected quality defects have been removed.

Transferring Experience from Software Engineering Training in Industry to Mass University Education - The Big Picture

This paper shows and critically discusses how experience gained from years of software engineering training in industry can be transferred to mass university education. The approach relies on cyclical, iterative and problem-based learning and places equal emphasis on technical skills (such as object-oriented and database programming) and soft skills (such as presentation techniques, handling personal conflicts and cooperating in a team context)

Application-oriented usage quality: the tools and materials approach

One of the main goals of software development is to provide the user with useful and usable software. Many different techniques are employed to ensure that the analysis, design and construction of software leads to a product with quality in usage. However once a system is shipped and installed at the user’s site the gap between the developer’s idea of usage quality and the user’s needs becomes obvious. From our point of view usage quality can only be achieved by placing a strong emphasis on the application area. The software developer on the one hand needs to understand the user’s tasks. The software product on the other should represent the main concepts of the application area. By taking these two guidelines into consideration, software with application-oriented usage quality can be produced.

Domain-driven framework layering in large systems

Frameworks are the key to successful object-oriented application development. The goal of this paper is to show that successful framework development must match the business domains they are derived from, and that they must be flexible enough to evolve gracefully. Our principal contribution is the presentation of concepts that can be used for domain partitioning and framework layering in order to overcome difficulties in framework construction and layering. The work reported here is based on a series of object-oriented banking projects. The system, including several frameworks, consists of 3500 C++-classes and was developed over the past five years.

A Cognitive Model for Software Architecture Complexity

This paper introduces a Software Architecture Complexity Model (SACM) based on theories from cognitive science and system attributes that have proven to be indicators of maintainability in practice. SACM can serve as a formal model to reason about why certain attributes influence the complexity of an implemented architecture. Also, SACM can be used as a starting point in existing architecture evaluation methods such as the ATAM. Alternatively, SACM can be used in a stand-alone fashion to reason about a software architectures complexity.

Kooperation für Software für Kooperation - Erfahrungen aus einem partizipativen Softwaretechnikprojekt

Welche Methoden und Kenntnisse zum „Kern“ der Informatik gehoren, wird — einhergehend mit der rapiden Entwicklung der Informationstechnik und ihrer Nutzung — immer wieder neu diskutiert.1 Direkt damit zusammen hangt die Frage: „Welches sind die Aufgaben und Ziele der Informatik-Ausbildung?“

Software architecture analysis and evaluation

A software architecture describes the structure of a software system on an abstract implementation independent level. In forward engineering it serves as a blueprint to prescribe the intended software structure (so-called architecture model). In reverse engineering it can provide an abstract view of the actual code structure of the existing software system (so-called code architecture). Architecture models and actual code architectures play a vital role for all comprehension and communication tasks during the development and evolution of large software systems. Therefore, architecture models and code architectures have to be explicitly represented and consistently maintained during the development, maintenance, and reengineering processes. The need to insure compliance of the architecture model and the actual code architecture has drawn considerable attention in recent years. In order to facilitate maintainability and enhancement of a software system the compliance of the architecture model and the actual code architecture is essential. Various tools have been developed to analyse and evaluate the deviation of code architecture and architecture model. In this tutorial we present static analysis tools that may be used for architectural analyses. We demonstrate how these tools can create useful architectural views for different evaluation tasks such as identification of reconstruction scope, critical architectural elements and potential design irregularities. If possible we will analyse a software system provided by a participant of the workshop in a life demonstration.

Operating and window systems will never strike back or independence day for Java developers

With the use of Java and the JDK*, independence from specific platforms (operating systems and window systems) becomes possible. For the development of commercial applications however, Java and the JDK are not enough, and tools such as a GUI-builder are needed. When employing a GUI-builder, new dependencies on the builder-generated code have to be considered. Independence is an important prerequisite for enabling portability and reusability. There are many GUI-builders on the market and it is impossible to say which will end up being successful. However, integration of existing programs designed with different GUI-builders is an ongoing problem. We have designed and implemented a Java framework, which uses a GUI-builder independent format to store GUI resources. This framework can be combined with any GUI-builder that supports JavaBeans.