Contracts were introduced by Helm et al. as a high level construct for explicitly specifying interactions among groups of objects. This paper describes further developments and application of the Contract construct. We show how Contracts can be used to represent classic algorithms as large grained reusable object oriented abstractions, how these algorithms can be customized through Contract refinement and how they are reused through Contract conformance. The example algorithm used throughout is the classic graph depth first traversal algorithm. This algorithm is represented as a Contract which is then refined to specify algorithms which number connected regions of graphs and which check graphs for cycles. Changes to the Contract language are introduced and we discuss some new problems resulting from the simultaneous reuse of related contracts. 1 Introduction Contracts were introduced by Helm et al. [9] as a construct for explicitly specifying interactions among groups of objects. The...

A way to design software that… –emphasizes modeling of objects’ roles, responsibilities, and collaborations –uses informal tools and techniques –adds responsibility concepts and thinking to any process

The UML is recognized to be the dominant diagrammatic modeling language in the software industry. However, its support for building interactive systems is still acknowledged to be insufficient. There is a common misconception that the same models developed to support the design of the application internals are also adequate to support interaction design, leveraging the usability aspects of the applications. In this paper we identify and discuss the major problems using the UML to document, specify and design interactive systems. Here we propose a UML profile for interactive systems development that leverages on human-computer interaction domain knowledge under the common notation and semantics of the UML. Our proposal integrates with existing object-oriented software engineering best practice, fostering co-evolutionary development of interactive systems and enabling artifact change between software engineering and human-computer interaction. 1

This paper presents roles and role models as new abstractions for specifying, modelling, and designing intelligent agent systems. The approach is particularly valuable for applications that involve information and process management because it represents a unified approach. Software agents, objects, processes, organizations, and people can play roles and can therefore be incorporated into a role model. This paper provides an overview of role modelling and describes research at BT that is documenting role model patterns of intelligent agent systems. 1. INTRODUCTION The analysis and design of systems that include intelligent agents, as one type of software engineering, should answer the following questions (along with others): 1. What does this application do ? 2. Should intelligent agents be used in this application ? 3. What does each intelligent agent do ? 4. What goals, responsibilities, tasks, and expertise does each agent have ? 5. How do the intelligent agents interact with each...

Extreme Programming appears to be a solution for discovering and meeting requirements faster (through close customer collaboration) as well as creating quality software. In practice we found XP did deliver high quality software quickly, but the resulting product still failed to delight the customer. Although the finished product should have been an exact fit, the actual end-user still ended up slogging through the system to accomplish necessary day-to-day work. This paper describes using interaction design in an agile development process to resolve this issue. Using interaction design as a day-to-day practice throughout an iterative development process helps our team at Tomax Technologies deliver high quality software, while feeling confident the resulting software will more likely meet end-user expectations. The method of Interaction Design followed here is based on Constantine and Lockwood’s Usage-Centered Design. Recommendations are provided on how to practice an agile form of U-CD and how to incorporate bits of Interaction Design thinking into every day development and product planning decisions.

Abstract Complex systems call for a hierarchical description. Analogously, the engineering of non-trivial MASs (multiagent systems) requires principles and mechanisms for a multi-layered description, which could be used by MAS designers to provide different level of abstractions over MASs. In this paper, we first advocate the need for zooming mechanisms, promoting a coherent and consistent multi-layered view of agent systems. After surveying the best-known AOSE methodologies, we focus on the scaling mechanisms of the OPM process-oriented methodology. Then, by adopting SODA as our reference, we show how an AOSE methodology can be enhanced with simple yet expressive zooming mechanisms. Finally, we present a simple case study where the enhanced agent-oriented methodology (SODA+zoom) is exploited and put to the test. 1 Zooming as a Principle in the Design of MASs As advocated in [1], MASs (multiagent systems), once developed up to their

Abstract. Relationships have been an essential component of OO design since the 90s and, although several groups have attempted to rectify this, mainstream OO languages still do not support first-class relationships. This requires programmers to implement relationships in an ad-hoc fashion which results in unnecessarily complex code. We have developed a new model for OO languages which presents relationships as the dominant mechanism for defining object-oriented behaviour. We believe that a language based on this model could bring the benefits of relationships to mainstream languages and allow better integration between OO systems and other paradigms such as relational databases. 1

The omnipresent integration of computer technology in everyday applications introduces new opportunities to make software systems aware of the context in which they are used. Such context-aware systems can respond more adequately to user expectations. However, modelling the context influence inside of software systems burdens developers for several reasons. First, context-dependent behaviour might crosscut the application logic of a software system. Next, since software systems can simultaneously reside in multiple contexts, context-dependent behaviour should be composable. Furthermore, since context information is volatile, these compositions are subject to change at runtime. This paper explores how layered design approaches can be used to deal with these specific characteristics. 1.

Software frameworks typically constitute a semi-finished software architecture for a complex application domain that can be adapted to the needs and requirements of a concrete application in the domain. Since the introduction of objectoriented frameworks in the late eighties, the development of software frameworks is still costly and difficult to handle. To reduce development risk, process models and development methodologies for object-oriented frameworks have been developed, e. g., the hot-spot-driven approach by Pree. With the emergence of component technology also so-called component frameworks appeared that are currently considered as the highest level of software architecture reuse. In contrast to object-oriented frameworks, a proper process model for component frameworks is still missing. Such a process model needs support by a development methodology for identifying and specifying the framework's components. Consequently, the quality of today's component frameworks is eventually dependent on the experience and skills of the framework developers. The contribution of this position paper is a lightweight process model and development methodology for component frameworks. This process model is called ProMoCF and bases on the hot-spot-driven approach for object-oriented frameworks. ProMoCF extends it by activities and methodical support for identifying the framework's components and defining the framework's flexibility requirements by introducing so-called group-hot-spot-cards. In this position paper, we argue for the benefits of a lightweight process model for developing software frameworks. The proposed approach has been successfully applied to the development of our component framework for personalized multimedia applications.

A number of recent developments in software engineering --- from agile methods to aspect-oriented programming to design patterns to good enough software --- share a number of common attributes. These developments avoid a unifying theme or plan, focus on negotiation between different concerns, and exhibit a high level of context sensitivity. We argue that these developments are evidence of a postmodern turn in software engineering. In this paper, we survey a number of these developments and describe their potential implications for the practice of conceptual modelling.