Veröffentlichungen

2007

2006

2005

2004

2003

Abstract: The reflexion model originally proposed by Murphy and Notkin allows one to structurally validate a descriptive or prescriptive architecture model against a source model. First, the entities in the source model are mapped onto the architectural model, then discrepancies between the architecture model and source model are computed automatically. The original reflexion model allows an analyst to specify only non-hierarchical architecture models, which is insufficient for larger systems that are decomposed into hierarchical subsystems. This paper extends the original reflexion model to hierarchical architecture models, describes a method to apply this technique, and reports on case studies conducted on two large-scale and complex applications (namely, the C compiler sdcc for 8-bit microprocessors and the GNU C compiler gcc).

2002

2001

Abstract: Understanding a system's implementation without prior knowledge is a hard task for reengineers in general. However, some degree of automatic aid is possible. In this paper, we present a technique building a mapping between the system's externally visible behavior and the relevant parts of the source code. Our technique combines dynamic and static analyses to rapidly focus on the system's parts urgently required for a goal-directed process of program understanding.

• gnuzip-PostScript (40 kB)

2000

Vortragsfolien:

• PDF-Format (297 kB)

1999

1998

Abstract: Finite automata and their application in lexical analysis play an important role in many parts of computer science and particularly in compiler constructions. We measured 12 scanners using different implementation strategies and found that the execution time differed by a factor of 74. Our analysis of the algorithms as well as run-time statistics on cache misses and instruction frequency reveals substantive differences in code locality and certain kinds of overhead typical for specific implementation strategies. Some of the traditional statements on writing "fast" scanners could not be confirmed. Finally, we suggest an improved scanner generator.

Kurzfassung: Die zunehmende Komplexität heutiger Softwaresysteme bei gleichzeitig wachsenden Anforderungen an die Qualität der Endprodukte erfordert eine systematische Vorgehensweise bei der Entwicklung von Programmen. Neben anderen Faktoren kann auch die verwendete Programmiersprache zur Umsetzung moderner Prinzipien des Software Engineering beitragen. Ziel dieser Arbeit ist es, den Einfluß der Programmiersprache Ada auf den Projektverlauf bzw. auf die Produktqualität zu bewerten. Ausgehend von einer umfassenden Literaturrecherche wird anhand verschiedener Metriken untersucht, inwieweit sich bei der Verwendung von Ada Vor- oder Nachteile im Vergleich zu anderen Programmiersprachen ergeben.

• PostScript (919 kB)
• gnuzip-PostScript (433 kB)

Beitragstext mit Überlegungen zur Technologieentwicklung im Bereich des industriellen Einsatzes von Programmiersprachen im allgemeinen und speziell von Ada

• PostScript (129 kB)
• gnuzip-PostScript (49 kB)

• PostScript (369 kB)
• gnuzip-PostScript (65 kB)

Diese Bibliographie präsentiert Literaturquellen, die sich mit dem Einsatz von Ada befassen und obigen Arbeiten zugrundeliegen.

• Ada Projects Bibliography

1997

Abstract: In a recent project the Ada language turned out to be not as flexible as we expected it to be. This forced us to model our application in a way that was less elegant, less maintainable and less efficient. In this paper we propose to add a language construct to the language that would enable us to do what we were missing. The extension is based on finite unions with dispatching and can quite easily be integrated into the language and efficiently implemented.

• PostScript (118 kB)

Abstract: This article presents an approach to identify abstract data types (ADT) and abstract state encapsulations (ASE, also called abstract objects) in source code. This approach groups together functions, types, and variables into ADT and ASE candidates according to the proportion of features they share. The set of features considered includes the context of these elements, the relationships to their environment, and informal information. A prototype tool has been implemented to support this approach. It has been applied to three C systems (each between 30-38 Kloc). The ADTs and ASEs identified by the approach are compared to those identified by software engineers who did not know the proposed approach. In a case study, this approach has been shown to identify, in most cases, more ADTs and ASEs than five published techniques applied on the same systems. This is important when trying to identify as many ADTs and ASEs as possible.

• PostScript (184 kB)
• gnuzip-PostScript (52 kB)

Abstract: In the context of the authors' research on architectural features recovery, abstract data type (ADT) and abstract state encapsulation (ASE, also called abstract object) have been identified as two of the smallest components which are useful to build a significant architectural overview of the system. The authors have named these the atomic components of an architecture. This paper compares five published techniques which extract ADT and ASE from source code. A prototype tool implementing each technique has been developed and applied to three medium-size systems written in C (each over 30 Kloc). The results from each approach are compared with the atomic components identified by hand by a group of software engineers. These people did not know the automatic techniques which were going to be applied to the systems.

• PostScript (207 kB)
• gnuzip-PostScript (61 kB)

Abstract: This paper presents a method to view a system as a hierarchy of modules according to information hiding concepts, and to identify architectural component candidates in this hierarchy. The result of the method eases the understanding of a system's underlying software architecture. A prototype tool implementing this method was applied to three systems written in C (each over 30 Kloc). For one of these systems, an author of the system created an architectural description. The components generated by our method correspond to those of this architectural description in almost all cases. For the other two systems, most of the components resulting from the method correspond to meaningful system abstractions.

• PostScript (359 kB)
• gnuzip-PostScript (69 kB)

Abstract: Aliasing is an old but yet unsolved problem, being disadvantegous for most aspects of programming languages. We suggest a new model for variables which avoids aliasing by maintaining the property of always having exactly one access path to a variable. In particular, variables have no address. We develop rules for a language using these variables which can be checked in local context and we suggest programming guidelines to prevent alias effects in Ada 95 programs.

• PostScript (140 kB)

Abstract: Cocktail is a compiler toolkit originally developed by the "Gesellschaft für Mathematik und Datenverarbeitung" (GMD) at Karlsruhe, Germany. It supports all phases of compiler construction by providing generators for scanners, parsers, abstract syntax trees, attribute evaluators, traversers of abstract syntax trees, and back ends. The original toolkit generates C and Modula-2 code. We adjusted the tools (other than the code generator) to generate Ada 83 code before Ada 95 became standardised and any Ada 95 compiler was available. The generated Ada 83 code is quite similar to generated Modula-2. When the Ada 95 compiler Gnat had been released, we took advantage of the object-oriented features of Ada 95 for code generation. This led to a major simplification of the generated abstract syntax tree. Nevertheless, in taking advantage of the possibility to define dispatching operations, we observed an explosion of the generated code, which led to tremendously longer compile times compared to the former Ada 83 code. Finally, we realised that the object-oriented features of Ada 95 were not sufficient to support the code generation as conveniently as we had expected.
All Cocktail tools we adjusted to Ada are freely available.

1996

Abstract: Although GOTO has long been criticized for being "unstructured" and causing "unreliable" programs, it is still in use and even modern languages like Ada95 provide GOTO. Why? This paper presents the results of a study in which we examined 316 MB of Ada source code in order to find the frequency and typical applications of GOTO. It turned out that about 99% of all examined files do not contain any GOTO, but we also found "spaghetti code", generally justified by efficiency arguments. We analyzed whether GOTO really improved efficiency and examined sources containing GOTO by code inspection in order to determine its typical applications.

• PostScript (197 kB)

Abstract: In the object-oriented extension of Ada 95 some constructs and connected type rules have been introduced that restrict the flexibility in using the whole set of features the object-oriented paradigm provides. Especially the introduction of tagged types leads to a loss of potential reuse if efficiency is of concern while the rules connected with dispatching disable full static type checking for subprogram calls. A closer investigation of these constructs and constraints reveals that some of them are completely unnecessary and some could be relaxed with minor changes of the language. With corresponding modifications, the language gains additional flexibility and becomes easier to use, while, through the introduction of multi-methods, the language regains the property of being statically type-safe.

• Originalfassung (PostScript, 117 kB)
• überarbeitete Fassung (PostScript, 117 kB)

Kurzfassung: Programmverstehen ist der Prozeß des Wissenserwerbsüber ein Computerprogramm. Es ist die Voraussetzung für Fehlersuche, Erweiterung, Wiederverwendung und Dokumentation. Eine Reihe von Ansätzen versucht, das Programmverstehen maschinell zu unterstützen. Die gegenwärtigen Ansätze werden in diesem Artikel klassifiziert in grundlegende und wissensbasierte Analysen.
Grundlegende Analysen verfügen über kein Wissen über die Anwendung und allgemeine Programmierung; sie basieren lediglich auf Programmiersprachensyntax und -semantik. Sie lassen sich weiter gliedern in grundlegende statische und dynamische Analysen, abhängig davon, ob sie zur Übersetzungszeit oder zur Laufzeit vorgenommen werden. Wissensbasierte Analysen verfügen über Anwendungswissen und allgemeines Programmierwissen. Sie lassen sich unterscheiden in Parsing-Ansätze,die sich ausschließlich auf formale und strukturelle Programmeigenschaftenstützen, und informelles Schließen, welches darüber hinaus auch noch informelle Information in Betracht zieht.
Der Artikel gibt Beispiele zu den verschiedenen Analyseformen.

• PostScript (249 kB)
• gnuzip-PostScript (72 kB)

Abstract: This paper presents the results of a study in which we examined about 50 massively parallel programming languages in order to detect typical approaches towards supporting parallelism. Based on a classification into nine classes, semantic properties affecting the development of parallel programs are compared. From a consideration of the general function of programming languages in software engineering, we derive basic requirements on parallel languages.

• PostScript (851 kB)
• gnuzip-PostScript (469 kB)
• Vortragsfolien (gnuzip-PostScript, 335 kB)

1995

Abstract: DHOP (Distributed Higher Order Processes) is a small programming language for distributed systems based on the behavioural paradigm of process calculi. It has modern features like static typing, first class processes, and a dynamically reconfigurable network topology. Unlike most of similar languages which also rely on message passing, DHOP enforces directed one-to-one communication channels between processes. A typing system using the idea of linear types allows statically to check this one-to-onecondition. The soundness of the typing system can be shown based on the operational semantics that is defined by means of graph grammars.

• gnuzip-DVI-Version (8 kB)

1994

• gnuzip-PostScript (54 kB)

• gnuzip-PostScript (82 kB)

• gnuzip-PostScript (73 kB)

1993

1992