Jörg Niere

Towards pattern-based design recovery

A method and a corresponding tool is described which assist design recovery and program understanding by recognising instances of design patterns semi-automatically. The approach taken is specifically designed to overcome the existing scalability problems caused by many design and implementation variants of design pattern instances. Our approach is based on a new recognition algorithm which works incrementally rather than trying to analyse a possibly large software system in one pass without any human intervention. The new algorithm exploits domain and context knowledge given by a reverse engineer and by a special underlying data structure, namely a special form of an annotated abstract syntax graph. A comparative and quantitative evaluation of applying the approach to the Java AWT and JGL libraries is also given.

Story Diagrams: A New Graph Rewrite Language Based on the Unified Modeling Language and Java

Graph grammars and graph rewrite systems improved a lot towards practical usability during the last years. Nevertheless, there are still major problems to overcome in order to attract a broad number of software designers and developers to the usage of graph grammars and graph rewrite systems. Two of the main problems are, (1) that current graph grammar notations are too proprietary and (2) that there exists no seamless integration of graph rewrite systems with common (OO) design and implementation languages like UML and C++ or Java.

The FUJABA environment

Fujaba is an acronym for From UML to Java And Back Again. The Fujaba environment aims to provide round-trip engineering support for UML and Java. The main distinction to other UML tools is its tight integration of UML class and UML behavior diagrams to a visual programming language. Our use of UML allows to model operations on graph-like object structures on a high-level of abstraction and leverages the user from programming with plain references at code level. Code generation from class diagrams is widely known and supported by most modern CASE tools. However, code generation from class diagrams creates class frames and method declarations without bodies, only. The actual work remains unsupported. The paper considers how Fujaba generates code from collaboration diagrams. It presents an example session.

Integrating UML diagrams for production control systems

The paper proposes to use SDL block diagrams, UML class diagrams, and UML behavior diagrams like collaboration diagrams, activity diagrams, and statecharts as a visual programming language. We describe a modeling approach for flexible, autonomous production agents, which are used for the decentralization of production control systems. In order to generate a (Java) implementation of a production control system from its specification, we define a precise semantics for the diagrams and we define how different (kinds of) diagrams are combined to a complete executable specification. Generally, generating code from UML behavior diagrams is not well understood. Frequently, the semantics of a UML behavior diagram depends on the topic and the aspect that is modeled and on the designer that created it. In addition, UML behavior diagrams usually model only example scenarios and do not describe all possible cases and possible exceptions. We overcome these problems by restricting the UML notation to a subset of the language that has a precise semantics. In addition, we define which kind of diagram should be used for which purpose and how the different kinds of diagrams are integrated to a consistent overall view.

Tool integration at the meta-model level: the Fujaba approach

Today’s development processes employ a variety of notations and tools, e.g., the Unified Modeling Language UML, the Standard Description Language SDL, requirements databases, design tools, code generators, model checkers, etc. For better process support, the employed tools may be organized within a tool suite or integration platform, e.g., Rational Rose or Eclipse. While these tool-integration platforms usually provide GUI adaption mechanisms and functional adaption via application programming interfaces, they frequently do not provide appropriate means for data integration at the meta-model level. Thus, overlapping and redundant data from different “integrated” tools may easily become inconsistent and unusable. We propose two design patterns that provide a flexible basis for the integration of different tool data at the meta-model level. To achieve consistency between meta-models, we describe rule-based mechanisms providing generic solutions for managing overlapping and redundant data. The proposed mechanisms are widely used within the Fujaba Tool Suite. We report about our implementation and application experiences .

Handling large search space in pattern-based reverse engineering

Large industrial legacy systems are challenges of reverse-engineering activities. Reverse-engineering approaches use text-search tools based on regular expressions or work on graph representations of programs, such as abstract syntax graphs. Analyzing large legacy systems often fail because of the large search space. Our approach to handle large search space in pattern-based reverse engineering is to allow imprecise results in means of false positives. We use the theory of fuzzy sets to express impreciseness and present our approach on the example of recovering associations.

Using FUJABA for the Development of Production Control Systems

Current production control systems for e.g. a factory for cars or any other complex industrial good face two major problems. First, production control systems need to become (more) dezentralized to increase their availability. It is no longer acceptable, that a failure of a single central production control computer or program causes hours of down-time for the whole production line. Second, todays market forces demand smaller lot sizes and a more flexible mixture of different products manufactured in parallel on one production line. Common specification languages for embedded systems, like SDL, statecharts, etc. focus on the specification of (re)active components of production control systems like control units, actors (e.g. motors, valves), and sensors (e.g. switches, lightborders, pressure, and temperature sensors), and on the interaction of such reactive components via events and signals. They provide no appropriate means for the specification of (more) intelligent, autonomous production agents. Such autonomous production agents need knowledge of manufacturing plans for different goods and of their surrounding world, e.g. the layout of the factory or the availability of manufacturing cells. In addition, such production agents have to coordinate their access to assembly lines with other competing agents. This paper proposes to use (object-oriented) graph structures for the representation of production agents and graph (object structure) rewrite rules for the specification of their behaviour. We show how the FUJABA environment may be used to specify production agents and generate their implementation and to validate them via a graphical simulation.

Thinking in Objects and their Collaboration: Introducing Object-Oriented Technology

Although many professionals in education believe that an ‘objects first’ approach is the best method of introducing object-oriented technology, there is no common agreement on how to start such courses. Current study programs often begin by teaching a chosen object-oriented programing language, where students are confronted by a large amount of syntactical detail. Instead of focusing on the basics of object-oriented technology, namely objects and their collaborations, difficulties in handling the details of the programing language lead to a very scattered knowledge of object-oriented concepts. This is dangerous, as learners are left with a set of unconnected knowledge fragments. Approaches which embed different knowledge fragments in an overall knowledge view are known as “cognitive apprenticeship” approaches. The main idea of cognitive apprenticeship is continuous practice. We present a learning environment for introducing object-oriented technology in upper secondary schools based on cognitive apprenticeship. We use a visual programing language to away from the details and provide tool support to aid practice. We present the learning sequencewhich is used and show the impacts it makes on the course structure in our experiment in the chosen object-oriented programming language The Joint Task Force on Computing Curricula IEEE Computer Society.

Fuzzy logic based interactive recovery of software design

This abstract presents an approach to semi-automatically detect pattern instances and their implementations in a software system. Design patterns are currently best practice in software development and provide solutions for nearly all granularity of software design and makes them suitable for representing design knowledge. The proposed approach overcomes a number of scalability problems as they exist in other approaches by using fuzzy logic, user interaction and a learning component.

Testing and Simulating Production Control Systems Using the Fujaba Environment

The Fujaba environment provides means for the specification of software systems in UML notation and it has the opportunity to simultate the specified applications beforehand. Therefore, Fujaba provides editors for UML class diagrams for the static aspects of a software system and it provides Story Diagrams for the specification of dynamic behaviour. Story Diagrams combine UML activity diagrams for control flows and an UML collaboration diagram like notation for graph rewrite rules. Statecharts can be used for the specification of reactive objects. In Fujaba, each diagram has a precise formal semantics and this enables us to generate Java code from the specification. The generated Java code is executed in a Java Virtual Machine (JVM) and can be visualized by an integrated object browser. This paper shows in a tool demonstration how to use the Fujaba environment in order to simulate a specification of a shuttle based production control system.