Product configuration management is presented as a practical application for a prototype-based object model. Data model requirements for a configuration system are first introduced using a realistic example from industry. Problems with the traditional type-instance model in this application domain are then identified and given as motivation for the prototype approach. A prototype-based object model with inheritance tree transformations, constraints and component relationships is presented as a tool for expressing dynamic configuration data. Finally, a sample configuration process is described using the prototype object model.

One of the advantages of prototype-based languages is that they provide self-sufficient objects which do not depend on classes or other objects for their definitions. But objects can refer to other objects, and the effects of these inter-object references introduce arbitrary, uncontrolled dependencies between objects. We propose adding an explicit notion of object ownership to control dependencies and references between objects. Object ownership can also enhance object cloning and avoid the prototype corruption problem, making programs easier to write and easier to understand.

Most of the existing aspect-oriented technologies are founded on a class-based object-oriented language. A whole other paradigm of objectoriented programming is thus ignored: prototype-based programming. In this paper we explore the impact of the di#erences of prototype-based and class-based programming on the design of crosscut languages and the implementation of weaving. Crosscut languages for prototype-based programs will definitely need to depend more on dynamic properties of the running program. In cases where some of those properties don't change too often, we propose the use of dynamically modifying code.

MASPEGHI 2004 is the third edition of the MASPEGHI workshop. This year the organizers of both the ECOOP 2002 Inheritance Workshop and MASPEGHI 2003 came together to enlarge the scope of the workshop and to address new challenges. We succeeded in gathering a diverse group of researchers and practitioners interested in mechanisms for managing specialization and generalization of programming language components. The workshop contained a series of presentations with discussions as well as group work, and the interplay between the more than 22 highly skilled and inspiring people from many di#erent communities gave rise to fruitful discussions and the potential for continued collaboration.

We introduce a new simple formalism in order to characterize sharing mechanisms in objectoriented languages. This formalism is based on the three notions of name sharing , property sharing and value sharing . We use it to identify the kind of sharing achieved by class-inheritance in classbased languages in a comparison with the one achieved by delegation in prototype-based languages. We also point out that there are two possible semantics for delegation links. 1 Introduction Prototype-based languages are traditionally opposed to class-based ones and many comparisons between them have already been proposed [4, 15, 12, 11]. More specifically the delegation mechanism, which is part of many prototype-based languages [1, 8], has been compared to the class-inheritance mechanism appearing in class-based languages. Both mechanisms are inheritance mechanisms and achieve some kind of sharing. The one achieved by delegation is still somewhat unclear. In [8] Lieberman claims that delegation...

Specification and modeling are the first phases of large-scale and complex software development. Abstraction is a fundamental human capability that permits us to deal with complexity. Inheritance provides the means to model abstraction hierarchies. The topic of this master's thesis is to analyze the concepts and applicability of inheritance in the specification and modeling phases of software development. Implementation-level and specification-level motivations for using inheritance are contrasted throughout the work. We explore the main differences and possible problems in using inheritance on different levels of abstraction. Implementation-level inheritance is found to be used quite liberally as an incremental modification mechanism, which leads to conceptual and implementation problems that are not present in the specification and modeling of systems. The main contributions are in analyzing how inheritance relates to distribution, concurrency, modularity and temporal properties.

INHALTSVERZEICHNIS