Workshops

The overall theme of the workshop is the relation between Web Services and object orientation. Such relation can be explored from different perspectives, ranging from system modelling and engineering to system development, management, maintenance, and evolution. Aspects of particular interest are the modularisation of a system into components and the (possibly cross-domain) composition and orchestration of different modules. Components and composition are closely connected with the issue of reuse, and an important thread of discussion within the workshop will address the way in which Web Services impact reuse.

Programming in the Large means to handle software with huge amounts of object and classes and relations between them. A commonly known problem of this is that people loose track of the coarse grained structures of a system. This effect is often addressed as object sea. Current state-of-the-art programming languages use object-orientation mostly to provide a fine-grained structure. How does this scale up in large systems? What are the practical experiences? How does the software industry today experience Programming in the Large and what problems are encountered and should be addressed by the academic world? These are the questions, the Workshop on Practical Problems of Programming in the Large shall address. We wish to provide a platform for practitioners to present their view on their currently most pressing problems in the above area of object orientation. We also want researchers to respond to the needs expressed ? either directly in one of the working groups or in the long run by a cooperation started as a possible outcome of the workshop. We envision a win-win-scenario were practitioners get ideas about how to use current research results in their business and researchers get feedback about the most pressing problems in industry.

The proposed workshop is a direct continuation of seven successful workshops, held at previous editions of ECOOP in Darmstadt (2003), Malaga (2002), Budapest (2001), Cannes (2000), Lisbon (1999), Brussels (1998) and Aarhus (1995). The QAOOSE series of workshops has attracted participants from both academia and industry that are involved/interested in the application of quantitative methods in OO software engineering research and practice. Quantitative approaches in the OO field is a broad but active research area that aims at the development and/or evaluation of methods, techniques, tools and practical guidelines to improve the quality of software products and the efficiency and effectiveness of software processes. The 2004 edition extends the scope of the workshop to quantitative approaches to other than object-oriented modeling, specification and programming methodologies and technologies. In particular component-based systems (CBS), web-based systems (WBS) and agent-based systems (ABS) will also fit into this new edition. Although wider in scope, the workshop will keep its original name for continuity sake. The relevant research topics are diverse, but include a strong focus on applying empirical software engineering techniques. Papers are invited, but not limited, to the areas of metrics collection, quality assessment, metrics validation, and process management.

Teaching and learning object-oriented concepts have proven to be very difficult in the past. Using traditional programming languages, concepts could be introduced step by step. Abstract and advanced concepts, like for example modules and abstract data types could be handled as an afterthought. In the object-oriented paradigm, however, the basic concepts are tightly interrelated and cannot easily be taught and learned in isolation. Switching to object-oriented development is not just a matter of programming languages. Focusing on the notational details of a certain language prevents students from grasping the “big picture”. Our traditional examples are furthermore not always suitable for the teaching and learning of object-oriented concepts. Many popular examples (like for example 'Hello World') actually contradict the rules, guidelines and styles we want to instil in our students. Educators must therefore be very careful when selecting/developing examples and metaphors. Rules and misconceptions that students develop based on doubtful examples will stand in the way of teachers and learners as well. This workshop will bring together people from industry and academia to share and discuss experiences, ideas and resources to support the teaching and learning of basic object-oriented concepts. This is the eighth in a series of workshops on issues in object-oriented teaching and learning.

The advent of Java has always been perceived as a major breakthrough in the realm of object-oriented languages. And to some extent it was: it turned academic features like interfaces, garbage-collection and meta-programming into technologies generally accepted by industry. Nevertheless Java also acted as a brake especially to academic language design research since most results on programming languages are currently formulated as extensions of Java. Therefore they necessarily follow the Java-doctrine: statically typed single-inheritance class-based languages with interfaces and exception handling. The goal of this workshop is to address object-oriented languages that radically diverge from this doctrine but support a much more dynamic way of constructing software. In the near future, this dynamicity will be required in order to construct software that is highly context-dependent due to the mobility of both the software itself and its users. This kind of software has recently been given the name Ambient Intelligence and was put forward as one of the major strategic research theme’s by the EU’s IST Advisory Group for the financing structure of the 6th Framework of the EU. The idea of Ambient Intelligence is that everybody will be surrounded by a dynamically defined processor cloud of which the applications are expected to cooperate smoothly. We believe that this emerging field will open up a new “market” for a new generation of dynamic programming languages that feature dynamic language features that are not so new. The goal of the workshop is to discuss new as well as older languages and features in this new context.

Object-orientation has provided many benefits in the context of complex systems development. The goal of providing a seamless mapping between objects in the real world and system objects, however, has turned out to be unrealistic in practice – causing concrete problems for systems maintenance and integration. Ontology has increasingly been seen as a ‘silver bullet’ for dealing with mapping but, to-date, initial attempts to pragmatically deploy it in computer science have been modest in their outcomes. This is because computing ontology to-date has been used primarily for (often competing) concept definitions and has ignored its philosophical roots to considerable degree. To a large extent, what is missing is a sound basis on which to properly align different views on aspects of the world in order to work towards a consistent whole. The focus of this workshop is thus placed on understanding and working toward that sound basis with the principal objectives of understanding (a) what philosophical ontology is, (b) whether, and how, ontology can assist in software development and (c) what the key obstacles to the deployment of ontology are.

System development is eased by abstraction and modeling. How to model distributed systems? Distributed systems can be understood as communicating objects. To tackle the problems of building distributed systems, it is useful to focus on the abstract issues of inter-component communication. Examples of distributed communication mechanisms include messaging systems, remote procedure calls, distributed objects, peer-to-peer, publish-and-subscribe... Within any such paradigm, there are many opportunities for specialized and detailed engineering decisions. While mechanisms such as these are a good foundation for dealing with the problems of distribution, there remain many issues about how to mold these ideas to deal with the problems of real systems. At the previous ECOOP workshops, we identified some problems (security, privacy, partial failure, guaranteeing quality of service, run-time evolution, meta-object protocols, and ordering of events) that are important concerns of any communication abstraction. The goal of this workshop is to contrast and compare communication abstractions for distributed systems. Participants will be asked to submit a position paper on some aspect of communication abstractions for distributed systems. To focus the group’s discussion, we consider the distributed aerospace information problem, described in the call-for-papers. Prospective participants are requested to relate their contribution to some facet of that problem.

Formal techniques can help analyze programs, precisely describe program behavior, and verify program properties. Newer languages such as Java and C\# provide good platforms to bridge the gap between formal techniques and practical program development, because of their reasonably clear semantics and standardized libraries. Moreover, these languages are interesting targets for formal techniques, because the novel paradigm for program deployment introduced with Java, with its improved portability and mobility, opens up new possibilities for abuse and causes concern about security. Work on formal techniques and tools for programs and work on formal underpinnings of programming languages themselves naturally complement each other. This workshop aims to bring together people working in these fields, on topics such as: specification techniques and interface specification languages automated checking and verification of program properties, verification logics, language semantics, type systems, dynamic linking and loading, and security. The workshop will be organized into four or more sessions, each initiated by a presentation of few related position papers by the respective participants, or the introduction of a topic by a single speaker, and followed by discussions.

Object- and component-oriented systems are the technology of choice for most new developments, and are finding extensive application in the domain of ubiquitous and context-aware computing. Highly ubiquitous, highly contextualised systems pose significant challenges for object-oriented methods and tools, however. Users of these systems expect to be able to make use of all the resources available in a space, selected at run-time and adapted to their specific tasks and constraints; designers of systems need to be able to satisfy these requirements in a way that is both predictable and extensible. It seems likely that these pressures will impact on both the design methods used to develop object-oriented ubiquitous computing systems and the languages and middleware used in their implementation. This workshop will address two fundamental questions: * What are the most significant limitations of object- and component-oriented technologies in addressing ubiquitous computing?; and * What developments are addressing these limitations? It will bring together researcher building ubiquitous computing applications with those developing the underlying tools, techniques and theories for modelling and representing context-aware systems, with a view to deriving a synergy of requirements and constraints to feed into future research and development activities.

This workshop is combined with the doctoral symposium, both addressing the same group of participants. PhD students in an early stage of their work should take part in the workshop, PhD students, who are nearly finished, should attend the doctoral symposium. The topics are derived from the area of interest and work of the PhD students. For each participant, this is an opportunity to present his/her research to a knowledgeable audience working in a similar context, and to share his/her ideas on hot-topics or new trends. In this way, the participants may receive insightful comments on their research, learn about related work, and initiate future research collaborations. To attend the workshop, a participant should send a short paper (ten pages or less) and be prepared to give a 30 minutes talk at the workshop itself. After the presentations, there will be room for discussions and work in smaller subgroups of PhD students working on similar topics. This will be followed by an invited talk about how to do PhD work. To participate in the doctoral symposium, a PhD student should send a brief description of their work and a letter of recommendation. He/she will discuss their work mainly with senior researchers with a strong background on some area of object-orientation. The review process for the doctoral symposium, as for the workshop as well, is not designed to select the few very best papers, but to ensure that every participant is able to present some relevant material, and is well prepared.

While OO has become ubiquitously employed for design, implementation, and even conceptualization, many practitioners recognize the concomitant need for other programming paradigms according to problem domain. Nevertheless, the choice of a programming paradigm is strongly influenced by the supporting programming language facilities. In turn, choice of programming language is usually a practical matter: one cannot generally afford to use a language not in the mainstream. We seek answers to the question of how to address the need for other programming paradigms in the general context of OO languages. Can OO programming languages effectively support other programming paradigms? The answer seems to be affirmative, at least for some paradigms; for example, significant progress has been made for the case of (higher order, polymorphic) functional programming in C++. What is clear, however, is that this field is yet nascent: novel, disparate approaches and techniques are still being discovered or invented; this very novelty adds a significant element of intellectual entertainment. This workshop seeks to bring together practitioners and researchers in this developing field to present and debate on their work and ideas--describe existing, developing, or proposed techniques, idioms, methodologies, language extensions, or software for expressing non-OO paradigms in OO languages and the .NET framework; or theoretical work supporting or defining the same.

MASPEGHI 2004 will continue the discussion about mechanisms for managing and manipulating specialization and generalization hierarchies: inheritance and reverse inheritance, specialization and generalization, interface and implementation inheritance, multiple, single, mixin and trait-based inheritance, etc. We are concerned with both the uses of inheritance, and the difficulties of implementing and controlling it. These concerns are reflected differently by disciplines such as databases, knowledge discovery and representation, modeling and design methods, object programming languages, with emphasis put either on problem domain modeling or on organizing the computational artifacts that simulate the domain. For example, in knowledge representation, the modeling role of classes prevails: hierarchies are repositories of validated knowledge, which support the acquisition of new knowledge. In analysis and design, the purpose of the hierarchy shifts as the design matures from modeling to organizing. Hence, modern OOA&D methods support the gradual evolution of class hierarchies from one use to the other. Despite the wide use of specialization hierarchies, there is no standard methodology for constructing and maintaining them independently from the domains that they represent and the artifacts that they organize. This workshop will provide a forum for researchers from a variety of domains to learn from each other and work together to develop such a methodology.

Software evolution and adaptation is a research area in continuous evolution, and offering stimulating challenges for both academic and industrial researchers. The evolution of software systems, to face unexpected situations or just for improving their features, relies on software engineering techniques and methodologies. Nowadays a similar approach is not applicable in all situations e.g., for evolving nonstopping systems or systems whose code is not available. Features of reflection such as transparency, separation of concerns, and extensibility seem to be perfect tools to aid the dynamic evolution of running systems. Aspect-oriented programming can simplify code instrumentation whereas techniques that rely on meta-data can be used to inspect the system and to extract the necessary data for designing the heuristic that the reflective and aspect-oriented mechanisms use for managing the evolution. We feel the necessity to investigate the benefits brought by the use of these techniques on the evolution of object-oriented software systems. In particular we would determine how these techniques can be integrated together with more traditional approaches to evolve a system and the benefits we get from their use. This workshop should be a good meeting-point for people working in the software evolution area, and an occasion to present reflective, aspect-oriented and meta-data based solutions to evolutionary problems, and new ideas straddling these areas.

Coordination and Adaptation are two key issues when developing complex distributed systems. Coordination focus on the interaction among computational entities. Adaptation focus on the problems raised when the interacting entities do not match properly. The topics of interest of the workshop cover a broad number of fields where coordination and adaptation have an impact: models, requirements identification, interface specification, extra-functional properties, documentation, automatic generation, frameworks, middleware and tools, and experience reports. To enable lively and productive discussions, attendance will be limited to 20 participants, and submission of a short position paper is required. Submissions should describe work-in-progress, open questions and participants’ expectations on the workshop. We suggest that position papers contain a specific final section identifying Open Issues. Participants will make a five-minutes presentation of their positions, followed by a discussion which must serve to identify a list of open issues in the field. Then, participants will be divided into smaller groups (4-5 persons each), attending to their interests. The task of each group will be to discuss about a set of the previously identified topics. Finally, a plenary session will be held, in which each group will present their conclusions to the rest of the participants.

Component-based software development, as a sub-area of object-oriented software development, has become a central focus in computing practice. However, due to the lack of appropriate language support, component-based software development remains a labor-intensive and costly undertaking. The aim of this workshop is to bring together researchers and practitioners in the area of component-based software development and to provide a forum to address important issues related to component composition using composition languages. We would like to determine the strengths and weaknesses of composition languages and compare it with similar approaches in related fields. Moreover, we are particularly interested in the refinement of concepts of composition languages and in bridging the gap between theory and practice. More precisely, we would like to emphasize the important issues of (i) design and implementation of higher-level models and languages for component-based software development, (ii) approaches that combine architectural description and component configuration, (iii) paradigms for the specification of reusable software assets, (iv) expressing applications as compositions of components, and (v) the derivation of working systems using composition languages. It is our intention to continue the fruitful discussions started at previous workshops on composition languages which were held in conjunction with ESEC/FSE 2001, ECOOP'02, and ECOOP'03.

Model Driven Architecture (MDA) is an initiative by the OMG to leverage UML-based modeling techniques to insulate abstract software system specifications from implementation dependencies. The workshop focuses on techniques that can be used to realize MDA, with a particular focus on support for the specification and execution support of non functional aspects of models. We aim to bring together practitioners, researchers, academics, and students to discuss the state-of-the-art of transformation and execution techniques in the context of MDA. The workshop will be interesting for researchers investigating the mentioned basic technologies in the context of model-based development.

The workshop focuses of technologies that support interoperability of Enterprise systems. The main goal is to discuss current trends in object and component technologies and to compare them with recent development in service-oriented and model driven system design. Basic technologies that are in the focus of the workshop are: object and component technologies, software architecture, model driven development, autonomous computing, ontologies, web services, and business process modeling. The workshop will be interesting for researchers investigating the mentioned basic technologies in a business application context as well as on researchers working on system integration and interoperability. Academics, researchers and practitioners interested in approaches aimed at defining the semantics for achieving the interoperability of enterprise systems are invited to submit position statements to this workshop.

WCOP 2004 seeks position papers on the important field of component-oriented programming (COP). WCOP 2004 is the ninth event in a series of highly successful workshops, which took place in conjunction with every ECOOP since 1996. COP is the natural extension of object-oriented programming to the realm of independently extensible systems. COP aims at producing software components for a component market and for late composition. Composers are third parties, possibly the end users, who are not able or willing to change components. Several component technologies emerged, including CORBA/CCM, COM/COM+, J2EE/EJB, and .NET. There is an increasing appreciation of software architecture for component-based systems and the consequent effects on organizational processes and structures, as well as the software industry in large. WCOP 2004 emphasizes the dynamic composition of component-based systems and component-oriented development processes. Dynamically composable software needs clearly specified and documented contracts, standardized architectures, specifications of functional properties and quality attributes, and mechanisms for dynamic discovery and binding. A typical example is web services. A service is a running instance that has specific quality attributes, while a component needs to be first deployed, installed, loaded, and instantiated. Comparing service and component composition models is interesting and a proposed workshop focus. Flexible development processes (such as agile ones) and component-based development support each other in that the use of existing components can reduce the development effort. Positions on development processes relating to the use of components are welcome. Finally, we also solicit reports on practical experience with component-oriented software, where the emphasis is on interesting lessons learned.

Note: this workshop has been cancelled.

The success of object-oriented programming has also meant the widespread acceptance of reusable frameworks. Frameworks now supply many areas of core functionality in a standard way, both across the industry as well as within a single enterprise. Many applications now consist of only a small amount of application code, and rely heavily on numerous disparate frameworks. This class of framework-intensive applications is becoming increasingly prevalent, on the server side as well as on the client. For example, web application server frameworks implement such things as security, transactional persistence, and complex resource management schemes. On the client, for example, the Eclipse frameworks standardize such capabilities as user interface integration (JFace) and modeling (eMF). While the use of frameworks has many obvious advantages in easing development of larger and more integrated systems, it also presents new challenges at various stages of the development lifecycle. For example, hidden semantics in framework code can make it easy to introduce subtle errors; hidden implementations can lead to performance problems; and problems that weave through multiple frameworks and application code can be difficult to diagnosis. We believe the growing prevalence of this class of application warrants focused study. This workshop aims to bring together researchers and practitioners to explore the characteristics, challenges, and new research opportunities unique to these applications. We are soliciting experience papers, position papers, speculative papers, and research papers that explore characteristics of these applications, the issues they pose, and any tools, analysis techniques, and methodologies that apply to them at various stages of the development cycle.

The ECOOP Workshop on Mobile Object Systems is now in its 10th year. Over the years, the workshop has dealt with a wide variety of topics related to the movement of code and data between platforms, including security, operating system support, mobile devices, application quality of service, language paradigms, agents and resource management. In some cases, the workshop has considered traditional object-oriented issues from a different angle. To mark the tenth anniversary of the workshop, we wish to revisit all of these themes, and in particular, to discuss the success and failure of mobility, compared to what was envisaged 10 years ago, and to discuss its future.

Developing operating systems (OSs) is a highly complex task. OS programmers often have to deal with millions of lines of code and common OS issues like concurrency, performance optimization, real-time, deadlocks, and configurability make their work even harder. Today, the historic language C - created in the early seventies - is still predominantly used to implement OS. Only in a few cases have OS implementors switched to more advanced languages like C++ or Java. Developing a new kernel and device drivers from scratch is often rendered impossible by the sheer size and complexity of operating systems. Thus, research is often limited to extend or modify existing systems. Widely deployed general purpose OSs like Linux and the Windows OS family continue to be developed using very conservative methods and languages. Modern software engineering concepts and languages, which are well-known and proven in other domains, are not adopted for the sake of performance optimization and backward compatibility. However, the arousing discussion about security and reliability of OSs especially with respect to internet attacks is an example that shows the drawbacks of the traditional development approach and a demands for new ideas. In this workshop we want to address this problem from the programming language perspective and bring together researchers from both domains. The aim is to facilitate a lively discussion about novel approaches in OS construction based on language concepts in general. Examples are object-orientation, type safety, language support for OS verification, testing/debugging, separation of concerns by aspect-oriented programming, and domain-specific languages.

The ability to reengineer object-oriented legacy systems has become a vital matter in today's software industry. Early adopters of the object-oriented programming paradigm are now facing the problems of transforming their object-oriented "legacy" systems into full-fledged frameworks. This Workshop on Object-Oriented Reengineering wants to gather people working on solutions for object-oriented legacy systems, and will be set up as a forum for exchanging experiences, discussing solutions, and exploring new ideas. We explicitly sollicit experience reports from the software industry as well as contributions from tool produces and methodology providers.

Although through frameworks and libraries object-oriented and component technology significantly improved the development of software, the obtained abstraction level still contains a lot of technical details and concerns. Domain-specific languages (DSLs) on top of object oriented and other general-purpose languages raise the abstraction level up to the level of a domain expert. Despite the enormous potential of DSLs, their development is usually feasible only for mature domains because of its cost and required expertise. Domains evolve over time and we know that “one size doesn’t fit all”. Developing a DSL each time from scratch is too costly. Therefore DSLs must be easily to evolve and the DSL specification be adaptable to a specific context. The workshop aims to bring together researchers and practitioners to discuss issues in DSL development and evolution with the particular focus on identifying, extracting, and composing reusable parts of DSL specifications. We specifically concentrate on, but not limit this workshop to, the use of object oriented techniques and concepts like encapsulation and inheritance to make DSLs more reusable. The goal is to share new ideas and experience, consolidate successful techniques, and identify open issues for future work.