Chair of Software Engineering

 

Mini-symposium on Component-Based Software Engineering, 20 August 2002

 

 Time and place

Tuesday, 20 August 2002, 8:30-17:00
Room: ETH, RZ F21  

 Program

+ Bernhard Rumpe, TU Munich
    Agile software development with the UML
    8:30-9:15

+ Joseph Kiniry, Caltech / Kind Software
    A Meta-Component Model via Kind Theory
    10:30-11:15

+ Peter Mueller, Deutsche Bank
    Modular Specification and Verification of O-O Software Components
    13:15-14:00

+ Andreas Rausch, 4Soft GmbH, Munich
    Componentware - Concepts and Specification Techniques
    15:15-16:00

   

 Abstracts and biographies

Bernhard Rumpe: Agile Software Development with the UML

Dr. Bernhard Rumpe, Software & Systems Engineering, TU München

Software and software-based systems become increasingly complex. Business systems, e.g., started out as stand-alone applications, then where integrated within companies and now become connected through the internet in e-commerce platforms.

Driven by complexity and diversification, a portfolio of development techniques that are applicable in a variety of development contexts has emerged. Such a portfolio allows developers to select and adapt processes, methods, and techniques based on the application domain and the criticality and complexity of the system to be built.

New application domains, such as e-commerce, require flexible approaches to meeting the to develop high quality software cheaply and rapidly. This talk will give an overview of work on integrating two development approaches. UML-based approaches emphasize the modeling of software from a variety of views. Agile development methods de-emphasize software modeling, while emphasizing disciplined coding and testing.

The integrated approach is based on the use of an adapted version of the UML as a modelling, coding and test notation. The talk will examine how the UML needs to be adapted to support rapid development, and how the software development process stands to benefit from the adaptation. In particular the evolution of the UML models according to changing requirements or technology through systematic adaptation ("refactoring") steps will be discussed, its underlying theory explored, and demonstrated in examples. The talk will also address the relationship between refactoring of models and code generation, automated tests and common ownership of models.

Dr. Bernhard Rumpe currently holds a fellowship position at the Technische Universität München awarded from the Bavarian Government.

His main interests are software development methods and techniques at the border between rigorous and practical methods. This includes the impact of new technologies and application areas, such as UML, agile methods and e-commerce, to companies as well as the methodical and technical issues of their application.

In various publications he contributed to the UML standardization as well as to the development and enhancement of software engineering processes. He is a contributor to the "Virtual Software Engineering Competence Center" (ViSEK.de) a newly founded countrywide project to bring together competence and information about software engineering in Germany.

He was organizer of the UML'99 conference in Colorado, involved in a number of SE related conferences (e.g. XP- and UML-series) and workshops. He is author and editor of eight books, among them the UML Adaptation for Frameworks (UML-F). He also is Editor-in-Chief of the new Springer International Journal on Software and Systems Modeling (www.sosym.org).

Joseph Kiniry: A Meta-Component Model via Kind Theory

Dr. Joseph Kiniry, Caltech / Kind Software

I will summarize a new logic called "kind theory" that is meant to help represent and reason about the basic, intuitive semantics of reusable assets. The formalism is somewhat unusual in that it was designed with the user in mind, it has a loose, adaptable semantics that can be refined for new problem domains, and it is grounded in the epistemological foundations of knowledge and software reuse in open, collaborative environments. I will also briefly discuss a complementary set of tools and constructs that realize and utilize the theory, including a basic theorem prover, a reusable asset repository, and a new specification construct called "semantic properties". This theory and these tools provide the foundation for a new "meta-component model", a simple, flexible, language-independent component framework that has several interesting properties with respect to research in component specification and composition.

Joseph Kiniry is a Ph.D. graduate from the California Institute of Technology in Pasadena, CA. His research interests include formal methods, foundations of mathematics, software engineering, object-oriented systems and languages, components, distributed systems, knowledge representation, systems modeling, artificial life, and the many different theoretical underpinnings of computing. While a graduate student at Caltech, he has started several technology firms whose focuses have been distributed systems, software engineering with formal methods, and massive multiplayer entertainment. Prior to Caltech he worked as an independent consultant and as a researcher at the Open Software Foundation Research Institute. He also holds degrees from the University of Massachusetts at Amherst and Florida State University.

Peter Mueller: Modular Specification and Verification of O-O Software Components

Dr. Peter Mueller, Deutsche Bank, Frankfurt

An object-oriented software component is a reusable, extendible, and adaptable set of classes that work closely together to achieve a common functionality. Such components are correct if they behave according to their specifications in all well-formed contexts in which they might be reused. Consequently, to be applicable to components, a specification technique must be capable of expressing component properties without knowing the contexts in which the component will be reused. Similarly, a verification technique must allow one to prove that a component behaves according to its specification in all well-formed contexts. Specification and verification techniques that meet these requirements are called "modular".

The talk presents a formal, modular specification and verification technique for object-oriented components. It illustrates the main modularity problems and explains their solutions. Special emphasis is given to the so-called frame problem, that is, the modular specification of side effects of method executions. The frame problem is solved by combining a state-of-the-art specification and verification technique with a type system for static alias control. This approach can also be applied to the modular specification and verification of class invariants. The talk concludes with an overview of tool-supported program verification and a perspective for applying the presented techniques in practice.

Peter Mueller works as a project manager for large software development projects at Deutsche Bank in Frankfurt, Germany. Before that, he was a member of the Verificard and Lopex research projects at Fernuniversitat Hagen and Technische Universitaet Muenchen. He received his Ph.D. in Computer Science from Fernuniversitaet Hagen in 2001. His thesis on "Modular Specification and Verification of Object-Oriented Programs" combines a type system for static alias control with a formal interface specification and verification technique, and applies this approach to a subset of Java. Peter Mueller graduated from Technische Universitaet Muenchen in 1996 with a diploma thesis on "Specification and Implementation of an Annotation Language for an Object-Oriented Programming Language".

Andreas Rausch: Componentware - Concepts and Specification Techniques

Dr. Andreas Rausch, 4Soft GmbH, München

Componentware introduces a new software development paradigm. Systems are no longer implemented from scratch, but glued together from existing components - similar to the successful model from the building industry.

However, today's component-based software development approaches are mainly influenced by discussions on the underlying technical infrastructure. The model of the building industry was not completely transferred to component- based software development. This is partly due to the lack of a suitable componentware methodology. Such a methodology should at least incorporate the following parts:

* a well-defined conceptual framework of componentware is required as a reliable foundation.

* based on the formal model, specification techniques for components and component-based systems are needed.

* Component-based development should be organized according to a process model tailored to the specific needs of component vendors and component users.

In this talk we will introduce a formal model for components and component-based systems to unambiguously express the basic definitions and concepts, like interfaces, components and connections. These concepts are as simple as possible, yet sufficiently powerful to capture the essential concepts and development techniques of existing component-based infrastructures.

As it turns out, today's specification techniques are not sufficiently powerful to specifiy component-based systems. We show how these techniques can be leveraged to its full extent for component-based systems. Finally we provide the theoretical foundation of the proposed specification techniques based on the presented formal model.

Andreas Rausch received his Ph.D. in 2001 from the Technische Universität München at the chair of Prof. Dr. Manfred Broy, with the dissertation titled "Componentware - Evolution-based Development of Software Architectures". He is part of the large interdisciplinary research project FORSOFT, leading the subproject ZEN that is concerned with the foundations of software engineering. He has been leading various industrial software projects, developing large distributed systems, and is one of the four founders of the software house 4Soft GmbH.


Meyer home  -   Publications  -  Events  -  Chair of Software Engineering  -  CS Department