Clemens A. Szyperski

Component technology - what, where, and how?

Software components, if used properly, offer many software engineering benefits. Yet, they also pose many original challenges starting from quality assurance and ranging to architectural embedding and composability. In addition, the recent movement towards services, as well as the established world of objects, causes many to wonder what purpose components might have. This extended abstract summarizes the main points of my Frontiers of Software Practice (FOSP) talk at ICSE 2003. The topics covered aim to offer an end-to-end overview of what role components should play, where they should be used, and how this can be achieved Some key open problems are also pointed out.

Import is Not Inheritance - Why We Need Both: Modules and Classes

The design of many popular object-oriented languages like Smalltalk, Eiffel, or Sather follows a certain trend: The class is the only structuring form. In this paper, the need for having modules besides classes is claimed. Modules stem from a different language family and at first glance it seems that they can easily be unified with classes. Among other things, unifying modules and classes carries the danger of unifying the import and inheritance relationships. Constructs in several languages are discussed that indicate that modules and classes should indeed be kept separate.

Web services engineering: promises and challenges

Web services are emerging technologies to reuse software as services over the Internet by wrapping underlying computing models with XML. Web services are rapidly evolving and are expected to change the paradigms of both software development and use. This panel will discuss the current status and challenges of Web services technologies.

What characterizes a (software) component

The definitions and discussions below were contributed via e-mail. They are arranged by date. The experts, listed alphabetically above, participated in this virtual round table during the first quarter of 1998.

Architecting Systems with Trustworthy Components

Performance predictions of component assemblies and the ability of obtaining system-level performance properties from these predictions are a cru- cial success factor when building trustworthy component-based systems. In order to achieve this goal, a collection of methods and tools to capture and analyze the performance of software systems has been developed. These methods and tools aim at helping software engineers by providing them with the capability to understand design trade-offs, optimize their design by identifying performance inhibitors, or predict a systems performance within a specified deployment envi- ronment. In this paper, we analyze the applicability of various performance pre- diction methods for the development of component-based systems and contrast their inherent strengths and weaknesses in different engineering problem scenar- ios. In so doing, we establish a basis to select an appropriate prediction method and to provide recommendations for future research activities, which could sig- nificantly improve the performance prediction of component-based systems.Invited Articles.- Audition of Web Services for Testing Conformance to Open Specified Protocols.- A Core Theory of Interfaces and Architecture and Its Impact on Object Orientation.- Making Specifications Complete Through Models.- Bus Scheduling for TDL Components.- Refinement and Consistency in Component Models with Multiple Views.- Articles by Participants.- A Taxonomy on Component-Based Software Engineering Methods.- Unifying Hardware and Software Components for Embedded System Development.- On the Composition of Compositional Reasoning.- Trustworthy Instantiation of Frameworks.- Performance Prediction of Component-Based Systems.- Towards an Engineering Approach to Component Adaptation.- Compatible Component Upgrades Through Smart Component Swapping.- Exceptions in Component Interaction Protocols - Necessity.- Coalgebraic Semantics for Component Systems.- A Type Theoretic Framework for Formal Metamodelling.

Modular Programming Languages

Separating Concerns with Domain Specific Languages.- Event-Based Programming Without Inversion of Control.- Programming Language Concepts for Multimedia Application Development.- Implicit and Dynamic Parameters in C++.- Reconciling Virtual Classes with Genericity.- Oberon Script: A Lightweight Compiler and Runtime System for the Web.- Efficient Layer Activation for Switching Context-Dependent Behavior.- Object-Oriented Language Processing.- A Framework for Modular Linking in OO Languages.- Flexible Type-Safe Linking of Components for Java-Like Languages.- Towards a Formal Semantics for AspectJ Weaving.- Symbolic Analysis of Imperative Programming Languages.- Array-Structured Object Types for Mathematical Programming.- MetaModelica: A Unified Equation-Based Semantical and Mathematical Modeling Language.- A Component Language for Structured Parallel Programming.- Internal and External Token-Based Synchronization in Object-Oriented Languages.- A New Component-Oriented Programming Language with the First-Class Connector.- A Component Plug-In Architecture for the .NET Platform.- Improve Component-Based Programs with Connectors.- Automatic Object Colocation Based on Read Barriers.- Nearly Optimal Register Allocation with PBQP.- Fast Profile-Based Partial Redundancy Elimination.- The Dining Philosophers Problem Revisited.- A Mobile Agent Service-Oriented Scripting Language Encoded on a Process Calculus.- A Case Study in Concurrent Programming with Active Objects.

Component-oriented programming

This report covers the eleventhWorkshop on Component-Oriented Programming (WCOP). WCOP has been affiliated with ECOOP since its inception in 1996. The report summarizes the contributions made by authors of accepted position papers as well as those made by all attendees of the workshop sessions.

Overcoming independent extensibility challenges

Independent extensibility requires a strong handle on versioning through precise names.

Emerging component software technologies — a strategic comparison

Component software addresses the fundamental requirement that software systems need to be composed from components. Potentially, each component can evolve on its own as a product. Composition may be static, much in the sense of traditional product assembly, but could just as well be dynamic. Dynamic assembly is even required in the increasingly important case of content-oriented solutions. In all cases the effectiveness of a component approach will rest on the degree of standardization achieved in a specific domain. This article provides a strategic comparison of the two major competing component software standards: COM and CORBA/JavaBeans.

Lightweight Parametric Polymorphism for Oberon

Strongly typed polymorphism is necessary for expressing safe reusable code. Two orthogonal forms of polymorphism exist: inclusion and parametric, the Oberon language only supports the former. We describe a simple extension to Oberon to support parametric polymorphism. The extension is in keeping with the Oberon language: it is simple and has an explicit cost. In the paper we motivate the need for parametric polymorphism and describe an implementation in terms of translating extended Oberon to standard Oberon.