We demonstrate a new approach to refactoring which involves the decomposition of familiar high-level refactorings such as Extract method into their components. By understanding all refactorings as the introduction or elimination of degrees of freedom we show how a large proportion of programming edits are in fact micro-refactorings, and gain an insight into how tools that support these micro-refactorings could have a dramatic impact on developer productivity.

In this demonstration we will show the flow of the Mock Object development process by pair-programming to develop a code example. During the session, we will introduce the declarative jMock API and show how we use it to describe relationships between objects when developing test-first. We will show how this approach helps developers concentrate on real requirements and how it encourages a design in which objects are focused with well-defined responsibilities. We will also show our practices for maintaining the readability of tests written using jUnit with jMock. This work is described in a Practitioner Report at this conference, "Mock Roles, Not Objects".

Software architecture describes the high-level organization of a software system, and is essential both for reasoning about system properties and for implementing and evolving code. This demonstration will describe two architecture-related tools: AcmeStudio for architectural modeling and analysis, and ArchJava for ensuring consistency between architecture and implementation. AcmeStudio is an architectural design tool based on Eclipse, supporting graphical and textual descriptions of software architecture as well as various forms of architectural analysis. We will show how to create an architecture in Acme and check it against the constraints of an architectural style such as pipe-and-filter. ArchJava extends the Java language to include explicit architectural modeling constructs, and uses type system techniques to ensure that the implementation conforms to the architecture. We will show how AcmeStudio can generate skeleton ArchJava code, how developers can fill in this architecture with an implementation using an Eclipse-based ArchJava IDE, and how ArchJava's type system can help the developer to maintain consistency between code and architecture.

We will demonstrate several advanced refactorings for Java that have been implemented in the context of the Eclipse development environment for Java (see <b>www.eclipse.org</b>). These refactorings are semantics-preserving program transformations that are typical of the sorts of transformations object-oriented programmers perform manually in order to improve the structure of existing code, and to promote reuse, clarity, and extensibility.

Our demonstration will consist of three parts: (i) a quick review of the implementation in Eclipse of several widely-used refactorings such as <sc>Extract Method</sc>, <sc>Introduce Factory</sc> and <sc>Change Method Signature</sc> as described in Fowler's seminal book on refactoring, (ii) a demonstration of generalization-related refactorings such as <sc>Extract Interface</sc>, for extracting an interface from a class in order to reduce client dependencies on implementation particulars, and <sc>Generalize Type</sc>, for remediating over-specific declarations, and (iii) a demonstration of <sc>Genericize Container Uses</sc>, a refactoring that we are currently developing for migrating occurrences of standard container classes such as <b>ArrayList</b> or <b>HashMap</b> in a user's program to instantiations of the generic versions of these container classes in Java 1.5 (e.g., <b>ArrayList<String></b>). This involves determining the element types that flow into each container object, modifying their declarations and allocations sites where possible, and removing casts that have been rendered redundant.

The latter two categories of refactorings involve non-trivial static analysis, as well as challenging usability issues from a software engineering perspective, which reflect the complications that programmers face when performing the transformations manually. Therefore, during each demonstration, we will give a brief overview of the technical challenges that the refactorings present, along with highlights of the approach we took in addressing them. In particular, we will briefly describe a new piece of Eclipse infrastructure designed to help implement various kinds of context-sensitive and context-insensitive type and pointer analyses for Java.

A typical IDE based exploration of an OOP system will often involve multiple searches through class hierarchies, field accesses, method calls, regular expression matches and more. Developers who must follow connections between these disconnected views may find great difficulty in combining the capabilities of each view and may as well suffer significant disorientation due to loss of context while switching. toolname is a flexible, query-based source code browser that alleviates this disorientation by allowing the user to explore the various types of structural relationships between elements of the code without the distraction of switching tools. Using toolname, a developer can define his or her own top-level browsers on-the-fly by formulating logic queries and running them against the source code. Elements in the tree can then be queried individually in the same manner, allowing further exploration of the complex web of relationships that exist between scattered elements of code.

Radio Frequency Identification (RFID) technology provides the means to track any object, any time, anywhere with Electronic Product Codes (EPC). A major consequence of this technology is that the existing Information Technology systems, applications and processes have to be retrofitted to be EPC-aware. Many new systems and applications have to be developed while the technology and standards are still emerging. These will be driven by dynamic business processes and therefore have to be agile, and easy to use and modify by a business and sometimes non-IT savvy end user. We describe and use Distributed Application Specification Language (DASL) from Sun Microsystems, Inc., to model an enterprise application and deploy it directly on a target platform thus reducing the development lifecycle substantially. DASL provides for a rapid, intuitive modeling of enterprise applications. It abstracts application services such as persistence, tier'ing and messaging within the modeling language and enables a developer to focus more on the application domain. We discuss how we use DASL to model an application in the RFID domain, test for its correctness and proceed to deploy thus bringing about substantial efficiencies in the application development lifecycle.

As software systems evolve, they often grow more brittle. Design snippets help software engineers detect brittleness and improve the ease of change of their software. By studying design snippets and code together, a software engineer can locate improvements that prevent costly changes in the long term.

JeeWiz is a commercial tool for model-driven generation of enterprise-level systems. It can automate any part of the development process where repetitive work is required by meta-programming. JeeWiz is universal - being based on a meta modelling approach, it can describe and generate any software technology. It is used for both system-level generation (multi-tier J2EE,.NET, SOA systems) and design-level transformation (XMI to WSDL/XML Schema, and back). The most difficult problem we have confronted is the complexity of mapping from rich, high-level logical models to the detailed artifacts required in real-life systems. Some of the features JeeWiz provides to address this are: reusable architecture and technology layers; local flexibility and cross-tier patterns; and strategies for shielding application programmers from the complexity of infrastructures.

In summary, we need to satisfy demanding (and sometimes conflicting) requirements, namely to:<ul><li>represent both large-scale architectures and the fine-grained detail of programs</li><li>express general-purpose patterns as well as company-specific variations</li><li>manage simultaneous changes to model, hand-written code and code-generation patterns</li><li>encapsulate technology elements -languages, frameworks, architectures - into reusable layers</li><li>express models with logical information only but generate almost-complete physical systems.</li></ul>

These requirements make JeeWiz meta-programming particularly complex. Each major version of JeeWiz has been driven by the need to manage this complexity, and has pushed back the boundaries of what we can realistically express and generate. This process has resulted in a number of new elements - our "sub-atomic particles" of model-driven system generation. These are then used in a synergistic combination of meta-models, patterns, a framework for generation, and large-scale build techniques.

The demonstration will show these new elements in the context of <ul><li>specifying a model based on a meta-model</li><li>building transforms for real systems</li><li>meta-program maintenance, showing interesting combinations of the elements.</li></ul>

The JRockit Java virtual machine has a built-in capability to produce recordings of the runtime behaviour of an application environment. It is a light-weight system with a very low performance cost, which can give valuable insights as to how the JVM and application interact in production. The JRockit Runtime Analyzer (JRA) is a tool for analyzing these recordings by graphic visualization.

Smells are architectural, rather than functional, flaws in software that tend to reduce maintainability, extensibility, modularity, testability, or other software quality measures. Common smells include overly-long method bodies, message chains, parallel inheritance, use of switch statements to implement polymorphic behavior, data clumps, overly specific variable types, and duplicated code. Code duplication in particular is a well-known source of maintenance problems. Because smells do not represent functional flaws, they can be remediated by behavior-preserving transformations (i.e. refactorings).

We will demonstrate a nascent extensible smell detection framework for Java, implemented for the Eclipse IDE (www.eclipse.org). Our framework provides a simple Eclipse extension point for defining smell detectors, along with several basic smell detectors, including a reasonably efficient code duplication detector. Several of our smell detectors feature Eclipse quick-fix refactorings to automatically remediate smells upon the user's request. This transforms the tool from a mere problem indicator into a tool that actively assists developers in improving their code. We believe that such a facility has significant potential in educational settings, in directing a student's attention to software engineering principles while coding.

Our demonstration will consist of two parts. First, we'll demonstrate some of our smell detectors on realistic source code bases (including Eclipse itself), along with their corresponding quick-fix support. Second, we'll walk through the implementation of a very simple smell detector within our framework, along with a very simple remediation.

There are a number of technologies designed to improve modularity in software systems. The technique presented here combines two of them seamlessly to exploit their respective benefits: Eclipse plugins and AspectJ. The Eclipse runtime is based on the idea of plugins, enabling large systems to be built from smaller components. AspectJ is an AOP-enhanced version of the Java language that allows developers to modularize crosscutting concerns into aspects. While both technologies offer a number of interesting features, their seamless combination is not trivial. Several limitations make it impossible to exploit all the features of the combined technologies. AspectJ-Enabled Eclipse Runtime (AJEER) is designed to overcome these limitations. It integrates load-time weaving for AspectJ into the Eclipse runtime, thus allowing developers to implement aspects that modularize crosscutting concerns beyond the capability of individual plugins. In addition, the dynamic features of the OSGi-based Eclipse 3.0 runtime are preserved in this setting - making it possible to plug AspectJ aspects into and out of the running system dynamically.

Component-based software engineering enables applications to be assembled from component parts that adhere to a component-style specific interface specification and protocol. Components available for one style are not available for another. Component styles evolve, too, which can obsolete components using a legacy style. This creates a demand for migrating components from one style to another, which can require complex changes to the component source code. For a large component library, doing this manually is likely prohibitive. An alternative is to apply automated program transformations to carry out the changes.

Using source-to-source transformations on real code requires a scalable, robust program transformation technology. Such technologies are difficult to justify for single applications. DMS' is a commercial program transformation system which has been used to transform many programming languages, including C++, C#, Java and ObjectPascal. It is parameterized by language and desired task, enabling its infrastructure costs to be amortized across many different software analysis or change applications.

This demonstration shows a concrete example of DMS program transformations being used to migrate legacy C++ components from a Boeing distributed avionics software system, using a Boeing proprietary component format, to a CORBA component style. The conversion requires nontrivial understanding and manipulation of the C++ source code. It will explain the component migration problem to be solved, show some of the transformations, and actually convert a component.

This demonstration will feature overviews of the C-SAW and GenAWeave projects. The first half of the presentation will introduce the concept of two-level aspect weaving, which unites a <i>model transformation</i> tool with a <i>program transformation</i> engine. From models representing an avionics application, it will be shown how changes to model properties trigger corresponding adaptations to the related source code. The second half of the demonstration is focused on using a program transformation engine to perform the task of aspect weaving. In particular, several crosscutting concerns will be woven into an Object Pascal application.

The Concern Manipulation Environment (CME) aims to provide a set of open, extensible components and a set of tools that promote aspect-oriented software development (AOSD) throughout the software lifecycle. It has two main goals:

To provide an open, integrated development environment (IDE) to enable software engineers to use AOSD techniques throughout the software lifecycle, and to allow them to use different AOSD approaches in an integrated manner.

To promote the rapid development of new tools supporting AOSD at any stage of the software lifecycle, and to serve as an integrating platform for such tools, facilitating development and experimentation with new AOSD approaches.

This demonstration will highlight a number of tools and components that are useful to software developers and to AOSD tool providers and researchers. Tools for software developers include ones that allow developers to identify, model and visualize concerns, aspects and relationships in their software, covering software artifacts of any type, including both code and non-code artifacts, and including latent concerns or aspects that were not separated in the artifacts; that enable flexible queries over software; and that compose/integrate aspects and other concerns. For AOSD tool providers and researchers, the demonstration will describe some of the CME's support for integration of tools and approaches within the environment, highlighting the integration of Java, AspectJ and Ant artifacts within the CME, and how to use the CME's extensible components to create new AOSD tools or prototypes rapidly.

This demonstration illustrates how the visualization tool, Performance Explorer (PE), can be used to understand the behavior of Java applications. PE allows the visualization of data over time in various graphical and tabular ways. In addition, PE allows the interactive creation and modification of visualizations. Most properties of the visualization are defined using expressions in a language similar to Java expressions. Finally, PE has an extensible trace format that allows flexible data acquisition and aggregation.

Interactive graphical applications implicitly contain a large number of constraints -- relationships between objects, such as widgets and the underlying model they control. Encapsulation, a fundamental principle of object-oriented programming, is only guaranteed in a very limited sense by most object-oriented languages. ConstrainedJava provides a constraint system built upon stronger encapsulation guarantees which allows constraints to depend on entire aggregated objects.

Capturing the evolution of logical objects and structures in a software project is crucial to the development of a high-quality software. This research demonstration presents an <i>object-oriented</i> approach to managing the evolution of system objects at the <i>logical</i> level. Keys to our approach are its <i>extensible, logical,</i> and <i>object-oriented system model</i> and <i>structure versioning framework</i> in which types of logical objects and structures in a software system are extended from a small set of the system model's basic entities, allowing them to be versioned in a <i>fine-grained</i> manner and <i>independent</i> of the physical file structure. Changes to all logical objects and structures are captured and related to each other in a tightly connected and cohesive manner via the <i>Molhado</i> product versioning software configuration management (SCM) infrastructure. We also demonstrate our object-oriented SCM approach by applying it in different development paradigms such as UML-based object-oriented software development, architecture-based software development, and Web application development.

Nowadays, software needs to be more open, flexible, and capable of evolving quickly to meet new user or technology requirements. It should be easy to adapt, even by none computer-specialists. To tackle these challenges for DSL (<i>Domain-Specific Language</i>) tools, we have developed a software factory, named <sc>SmartTools</sc>.

Domain-Specific Modeling (DSM) raises the level of abstraction beyond programming by specifying the solution directly using domain concepts. In many cases, the final products can be generated from these high-level specifications. This automation is possible because both the language and generators need fit the requirements of only one company and domain.

This demonstration illustrates DSM by showing real world cases from various fields of software development. These cases describe how DSM, giving first class support for modeling, can prevent incorrect or unwanted designs at the early stages of development, and how full code can be generated from the modeler's point of view. Second part of the demonstration will show in an interactive manner both the design side and the use side of DSM languages and generators. Using MetaEdit+ tool for metamodeling, we define a DSM for a given domain and apply it to generate full code from high-level models.

In large scale software development projects, in particular in the field of Component-Based Software Engineering (CBSE), different kinds of a project's artifacts are used and related information is spread over the different artifacts. E.g., the transaction attributes ("Require", "Requires-New",etc.) of methods of an Enterprise Java Bean are defined in the deployment descriptor while the method bodies are defined in a Java class. If we want to put these information into relation, e.g., to find all methods with a specific transaction attribute, we have to use different search engines and have to map the information manually. It is not possible to execute "one query" that returns the desired result.

XIRC is a platform that enables to define queries over a uniform representation of all artifacts of a software project. XIRC maps all artifacts of a project to XML representations and stores the documents in a database. The database can be queried using XQuery, a functional query language for XML documents. XIRC can be used as a sophisticated search engine, as a tool to check implementation restrictions, to find errors or as a basis for further tools for code generation and visualization.

The primary objective of my dissertation is to develop an integrative view of agile software development to enhance our understanding and make predictions about the agile process. By modeling the dynamics of agile software development process, the applicability and effectiveness of agile methods will be investigated, and the impact of agile practices on project performance in terms of quality, schedule, cost, customer satisfaction will be examined.

We describe a novel approach to runtime visualization of object-oriented programs. Our approach features: visualizations of execution state and history; forward and reverse execution; interactive queries during program execution; and advanced drawing capabilities involving a combination of compile-time and runtime-analysis. Our methodology is realized in a software tool called <i>JIVE</i>, for <i>Java Interactive Visualization Environment</i>.

This research abstract outlines the work I plan to do as part of my PhD. In particular, I propose to devise a practical way of integrating ownership control into existing programming languages in a way that will help with adoption of ownership in the general programming community.

A long-standing goal of software engineering is to construct software that is easily modified and extended. Recent advances in software design techniques, such as aspect-oriented software development and refactoring, have offered new approaches to address challenges of software evolution. Several tools and language extensions have been developed by others to enable these techniques in a few popular programming languages. However, software exists in a variety of languages. An unfortunate consequence of legacy system adaptation is that new software engineering tools are often developed from scratch without preserving and reusing the knowledge gained from the previous construction of the tool in a different language and platform context. To address this problem, this paper summarizes two core research ideas. First, the concept of extending several software reengineering techniques in disparate programming languages is explored. A core focus of this objective is the abstraction of transformation functions to enable design maintenance in legacy based systems. The second research objective extends the first goal to understand the fundamental science for constructing a generic platform using grammar adapters to enable language-independent software maintenance.

The main goal of this PhD thesis is to propose and implement a methodology for the construction of programs based on the SCOOP model, and for modular reasoning about their correctness and liveness properties. In particular, the set of correctness rules that guarantee the absence of data races will be refined and formalized; an augmented type system will be proposed to enforce these rules at compile time. Furthermore, an efficient methodology for deadlock prevention, avoidance, detection, and resolution will be developed. A working implementation of SCOOP will be provided. It will take into consideration the proposed mechanisms and serve as a basis for further refinements of the model.

We propose a framework for removing redundant context management services in contextual composition frameworks, with focus on Enterprise JavaBeans. It is expected that by applying our framework, performance can be improved without the loss of modularity.

For the MDA approach to software development to become a reality for distributed enterprise systems, MDA needs to provide both modeling support for middleware-specific concerns and tool support for helping developers refine their designs along such concerndimensions at different MDA-levels of abstraction. In order to address these issues, the MDA-compliant Enterprise Fondue method proposes a hierarchy of UML profiles as a means for addressing middleware-specific concerns at different MDA-levels of abstraction, along with model transformations to incrementally refine existing design models according to the proposed profiles. Tool support is provided through the Parallax framework, which enables developers to modularize crosscutting concerns into aspectpromoting Eclipse plug-ins.

<i>Objects first</i> is a pedagogy that tries to introduce the core concepts of object-oriented programming - classes, objects, and methods - as early as possible in a programming course, even before variables, types, assignments and control structures are explicitly introduced. The concept of a named interface is typically introduced at a much later stage, usually in connection with inheritance, polymorphism, and abstract classes. In this paper we point out that interfaces as a language mechanism can be introduced much earlier, even before inheritance. This way the concept of an explicit class interface can be decoupled from the more complicated issues of inheritance and subtype-polymorphism.

History has given us the array as the fundamental data structure to present to students within the CS1 curriculum. However, with the recent growth in popularity of object-oriented languages for CS1 (C++, Java, C#), and with that, the acceptance of the objects-first or objects-early approach to teaching CS1, it becomes imperative that we re-evaluate our long-held beliefs about what is appropriate to teach. It is our position that the first data structure that students are exposed to should not be arrays, but rather some other form of collection. We will give some examples of how to use <i>java.util.HashMap</i> and some of the other Java Collections classes in substitution of arrays. We also present data concerning the academic performance of students using arrays versus those using Java Collections for CS1 lab exercises.

The introduction of programming education with object-oriented languages slowly migrates down the curriculum and is now often introduced at the high school level. This migration requires teaching tools that are adequate for the intended target audience.

In this paper, we present a new tool, named <i>greenfoot</i>, for teaching object-oriented programming aimed at students at or below college level, with special emphasis of supporting school age learners. Greenfoot was designed by analysing and combining the most beneficial aspects of several existing tools. It aims at combining the simplicity and visual appeal of microworlds with much of the flexibility and interaction of BlueJ.

To achieve its goals of providing a suitable learners' environment, greenfoot provides a meta-framework that allows easy creation of different, significantly varied microworlds.

Examples form an integral part of learning to program. In this paper we argue that the role of examples should go beyond merely illustrating concepts or principles and should "sell" concepts to new programmers. We identify four common pitfalls to avoid when designing examples for teaching programming. We show how examples that are too abstract or too complex can be harmful in explaining new concepts to students. We also show how some examples used to illustrate new concepts can undermine previously taught concepts by not applying these concepts consistently. Finally, we show how some examples can do harm by undermining the very concept they are introducing. The aim of this paper is to encourage educators to think critically about examples before using them.

Despite the importance of modeling in producing high-quality software, modeling often receives scant attention in academic curricula. The recent (sometimes heated) discussion of the Object Management Group's Model-Driven Architecture (MDA) has created an opportunity and offered the motivation for making modeling a more central part of the study of software designs. This paper discusses the rationale for modeling, how modeling is currently taught in one graduate program in Management Information Systems and some experiences in the teaching of modeling to masters' level graduate students.

We have designed a CS 1 course that integrates event-driven programming from the very start. In cite BDMITiCSE1 we argued that event-driven programming is simple enough for CS 1 when introduced with the aid of a library that we have developed. In this paper we argue that early use of event-driven programming makes many of the standard topics of CS 1 much easier for students to learn by breaking them into smaller, more understandable concepts.

The Shape Calculator is an assignment targeted at CS1 students in an objects-first curriculum. It can serve as a powerful yet entertaining example of the advantages of object-orientation.

In this paper, we describe two programming assignments based on a refactoring of the classic Game of Life application. In particular, we use the Game of Life to help teach freshman students two important and widely applicable design patterns - Command and Visitor.

We describe an assignment for students in a software engineering class or advanced programming class with emphasis on design. In the assignment students are given a program that solves a maze, with a display that shows the steps toward the solution. The given program has three variations of an iterative search (implemented using the strategy pattern), depth-first search, breadth-first search, best-first search (the latter using a priority queue). The students are asked to disentangle the problem-specific aspects of this code from the search strategy so as to define an abstract problem solver that can be applied to any problem fitting the model of step-by-step searching of a solution space. This requires three steps: defining appropriate interfaces that specify the information about the problem needed by the abstract solver, defining the abstract solver to find a solution using these interfaces, and defining the maze problem so as to implement these interfaces. With the abstract solver created, students should also be able to implement other problems fitting this model, such as the word-ladder game or a search in a graph for a Hamiltonian circuit, so that the abstract solver can be applied to them. The assignment demonstrates the power of generalization using abstract classes and interfaces as a bridge between concrete problems and the solution algorithm. This assignment is intended for a course in software engineering or an advanced programming course with emphasis on design. Students should already be familiar with object-oriented programming, inheritance, abstract classes and interfaces.

The Marine Biology Simulation is designed as a final project in an objects-first CS2 course. It provides an entertaining setting that serves as compelling example of the powers of object-oriented design and programming.

These notes have the status of letters written to ourselves: we wrote them down because, without doing so, we found ourselves making up new arguments over and over again. So began the abstract of our earlier paper <i>Notes on Postmodern Programming</i>. We now revisit the issue of postmodern programming, and attempt to address some of the questions raised by our exposition. To illustrate the nature of postmodernism we do not do this directly, but instead present a series of snapshots, parodies, and imagined conversations that we hope will help. What do you think of the abstract so far? Self-reference and a irreverent approach are part of this topic, so it's important to chill out and let things flow. We claim that computer science and software design grew up amid the unquestioned landscape of modernism, and that too often we cling to the otherwise ungrounded values, even as modernism itself is ever more compromised.

This paper explores a new point in the design space of formal reasoning systems - part programming language, part logical framework. The system is built on a programming language where the user expresses equality constraints between types and the type checker then enforces these constraints. This simple extension to the type system allows the programmer to describe properties of his program in the types of witness objects which can be thought of as concrete evidence that the program has the property desired. These techniques and two other rich typing mechanisms, rank-N polymorphism and extensible kinds, create a powerful new programming idiom for writing programs whose types enforce semantic properties. This kind of synthesis between a practical programming language <i>and</i> a logic creates a foundation for the design of languages of the future.

The modeling and enactment of business processes is being recognized as key to modern information management. The expansion of Web services has increased the attention given to processes, because processes are how services are composed and put to good use. However, current approaches are inadequate for flexibly modeling and enacting processes. These approaches take a logically centralized view of processes, treating a process as an implementation of a composed service. They provide low-level scripting languages to specify how a service may be implemented, rather than what interactions are expected from it. Consequently, existing approaches fail to adequately accommodate the essential properties of the business partners in a process (the partners would be realized via services)---their <i>autonomy</i> (freedom of action), <i>heterogeneity</i> (freedom of design), and <i>dynamism</i> (freedom of configuration).

Flexibly represented <i>protocols</i> can provide a more natural basis for specifying processes. Protocols specify <i>what</i> rather than <i>how</i>; thus they naturally maximize the autonomy, heterogeneity, and dynamism of the interacting parties. We are developing an approach for modeling and enacting business processes based on protocols. This paper describes some elements of (1) a conceptual model of processes that will incorporate abstractions based on protocols, roles, and commitments; (2) the semantics or mathematical foundations underlying the conceptual model and mapping global views of processes to the local actions of the parties involved; (3) methodologies involving rule-based reasoning to specify processes in terms of compositions of protocols.

Programmers tend to understand programs by thinking of concrete examples. <i>Example Centric Programming</i> seeks to add IDE support for examples throughout the process of programming. Instead of programmers interpreting examples in their head, the examples are written down and the IDE interprets them automatically. Advanced UI techniques are used to present the results closely integrated with the code. Traditionally distinct programming tools (the editor, Read-Eval-Print-Loop, debugger, and test runner) are unified into a single tool that might be called an <i>example-enlightened</i> editor. This is expected to benefit a wide spectrum of programming activities, for both novice and experienced programmers. Some novel methods for testing and development are made possible. In the longer term, example centrism has implications for the design of future programming languages. A prototype has been implemented for Java in Eclipse.

I argue that a successful switch from one methodology to another requires a switch from one <i>ontology</i> to another. Large-scale adoption of a new methodology means "infecting" people with new ideas about what sorts of things there are in the (software development) world and how those things hang together. The paper ends with some suggestions to methodology creators about how to design methodologies that encourage the needed "gestalt switch."

This paper is an extended abstract of the presentation at OOPSLA '04 and the full paper that will appear in the December issue of SIGPLAN Notices.

Many techniques have been developed over the years to automatically find bugs in software. Often, these techniques rely on formal methods and sophisticated program analysis. While these techniques are valuable, they can be difficult to apply, and they aren't always effective in finding real bugs.

<i>Bug patterns</i> are code idioms that are often errors. We have implemented automatic detectors for a variety of bug patterns found in Java programs. In this extended abstract¹, we describe how we have used bug pattern detectors to find serious bugs in several widely used Java applications and libraries. We have found that the effort required to implement a bug pattern detector tends to be low, and that even extremely simple detectors find bugs in real applications.

From our experience applying bug pattern detectors to real programs, we have drawn several interesting conclusions. First, we have found that even well tested code written by experts contains a surprising number of obvious bugs. Second, Java (and similar languages) have many language features and APIs which are prone to misuse. Finally, that simple automatic techniques can be effective at countering the impact of both ordinary mistakes and misunderstood language features.

Model Driven Architecture (MDA) is a technology that has been in the process of evolution for many years. We looked at this technology last year in a panel that raised the roof. Today, more vendors are now producing products that support MDA. And we still hear about the success stories that indicate that this technology is the "real deal". But, with the failed promises of CASE in the late 1980's, many people still have questions about how much of an application can be generated from models and constraint languages. Is MDA really capable of generating enterprise applications? What are the technologies are available to implement MDA? Are there really special skills needed to generate platform independent applications? How platform independent are they in practice? Here is your opportunity to ask the experts the questions that are necessary to convince you of the validity of this new technology. This time, we bring in the people who are shipping the technology.

We've have been proposing formal mathematical methods of software development for nearly as long as we've been developing software. CASE tools were a bust, and Gödel long ago nullified any hope of building a system that is both complete and consistent. Model-driven development gets trotted out in a new outfit once every decade as the next "silver bullet," but we're still far from drawing pictures that generate code.

Test-driven development almost produces executable specifications, but there's nothing mathematical or provably correct about them. Quality assurance happens during coding, but there's nothing to ensure that the entire system gets built, or that it's what the customer wants.

Agile methods propose "emergent design," where BDUF (big design up front) is old-fashioned and limiting. But agile methods work best with small groups of clever people to implement them; they have a hard time scaling.

The open-source movement, in which hobbyist programmers write code simply for the love of programming, has produced some of the best software in the industry. Is it good because people love what they're doing and build it for themselves to use? Or is it good because there are hundreds of eyes on the code?

Is software development a science or an art? Does it depend on mathematicians or on craftspeople? Are these viewpoints reconcilable?

J2EE and Microsoft.NET have emerged as two major frameworks for software development. Are they more similar than different or are the differences significant? How do they stack up against each other? This panel will offer a lively discussion from leaders of Microsoft and J2EE technologies.

This panel will conducted using the 'Question Time' panel (http://martinfowler.com/bliki/QuestionTimePanel.html) format, so called as it's inspired by a popular British current affairs show. Panelists won't make any position statements; instead we'll go directly to the interesting material - the questions. All questions to the panel need to be submitted on cards during the panel and the chair will decide which questions form an interesting set to discuss. We'll spend longer on each question to allow the panelists to get into more depth than is typical on more rapid fire panels.

If you are a software professional, your job is changing. Outsourcing and global development affect many things in our work environment: what and where we build, how (and when) we communicate, and how we prepare ourselves for the future.

Outsourcing and global development inherently create challenges with long-distance communication, cultural differences, and crossing organizational boundaries. For example, how do software interface contracts help or hinder system integration? How can a team in one country extend or maintain software built by developers in another country?

This Panel will appeal to anyone whose job is affected by outsourcing and globalization. Panelists will present and discuss both social and technical issues.

One of the core XP (Xtreme Programming) practices is that of the "on-site customer". In the words of Kent Beck (2000) in his book "eXtreme Programming Explained" the intent is that a "real customer must sit with the team, available to answer questions, resolve disputes, and set small-scale priorities" … "someone who will really use the system when it is in production". This panel brings together practitioners and researchers to discuss and offer wisdom on the challenges and opportunities inherent in the practice.

The world is changing; and this is also true for our IT business. Nicolai Josuttis talks with five international extraordinary female representatives of our IT business about the most important, thought-provoking, and funniest IT headlines and tendencies of the past year. Lean back and enjoy being a fly on the wall when the following participants chat in a pub-like atmosphere: Rebecca Wirfs-Brock, Linda Rising, Mary Lynn Manns, Jutta Eckstein, and Lise B. Hvatum.

The QuA project team at Simula Research Laboratory has prototyped an open source component middleware platform to support QoS sensitive applications. We are investigating the design of resuable QoS management components and tools to enable rapid construction of complex distributed systems.

Software architecture describes the high-level organization of a software system, and is essential both for reasoning about system properties and for implementing and evolving code. This poster describes two architecture-related tools: AcmeStudio for architectural modeling and analysis, and ArchJava for ensuring consistency between architecture and implementation. AcmeStudio is an architectural design tool based on Eclipse, supporting graphical and textual descriptions of software architecture as well as various forms of architectural analysis. The poster shows an example of creating an architecture in Acme and checking it against the constraints of an architectural style such as pipe-and-filter. ArchJava extends the Java language to include explicit architectural modeling constructs, and uses type system techniques to ensure that the implementation conforms to the architecture. The poster shows how AcmeStudio can generate skeleton ArchJava code, how developers can fill in this architecture with an implementation using an Eclipse-based ArchJava IDE, and how ArchJava's type system can help the developer to maintain consistency between code and architecture.

We evaluate events singly as gain or loss from status quo. We value sure gain, flee sure loss, assume progress cumulative. But progress relies on opportunism, taking advantage of tools and circumstances emerging through experience. Patterns, practices are superseded. Sometimes we refine, sometimes we invent, sometimes we stop using them.

Object oriented programming and design patterns introduce a high level of abstraction that allows us to implement and work with mathematical abstractions.

We analyze and design an object oriented algebraic library, that allows working not only with concrete algebraic structures, but also with abstract algebraic structures. The advantages of this approach mainly result from the usage of creational design patterns, reflection and dynamic loading, and representation independence. These introduce significant flexibility and abstraction. Using this library, we may work with abstract algebraic structures, such as: groups, rings, fields, etc., define new algebraic structures, and operate with them in abstract and concrete mathematical ways.

A simple alternative to MockObjects is presented. Given the interface of an object required by a class-under-test, a Pseudo-Class is created implementing all methods such that they immediately fail. A test-specific sub-class of the Pseudo-Class is created locally in the test (ex. as an anonymous inner-class in Java), over-riding only the methods required by the interaction between the object and the class-under-test for the test-scenario. Typically, the method implementations are extremely simple (a few lines, at most), and the number of methods overridden is small. This mechanism was found adequate for more than 90% of our unit-tests (in a 1000-class system with over 2000 test methods, we finally ended up with about four real MockObject classes and more than 40 Pseudo-Classes).

In this paper, we describe a compiler framework to enable the automated generation of compiler components for the Lucid family of intensional programming languages.

The integration of generative and aspect-oriented techniques is not a trivial task. This paper describes our experience in the definition of an aspect-oriented generative approach for the context of multi-agent systems. Our generative approach is composed of: (i) a domain-specific language called Agent-DSL, which allows to model crosscutting and non-crosscuting agent features; (ii) an aspect-oriented architecture that models a family of software agents; and (iii) a code generator that maps abstractions of the Agent-DSL to specific compositions of objects and aspects in specific implementations of agent architectures. The use of aspect-oriented techniques in the definition of our generative approach brought benefits to the modeling and code generation of crosscutting features since early design stages.

Radio Frequency Identification (RFID) technology provides the means to track any object, any time, anywhere with Electronic Product Codes (EPC). A major consequence of this technology is that the existing Information Technology systems, applications and processes have to be retrofitted to be EPC-aware. Many new systems and applications have to be developed while the technology and standards are still emerging. These will be driven by dynamic business processes and therefore have to be agile, and easy to use and modify by a business and sometimes non-IT savvy end user. We describe and use Distributed Application Specification Language (DASL) from Sun Microsystems, Inc., to model an enterprise application and deploy it directly on a target platform thus reducing the development lifecycle substantially. DASL provides for a rapid, intuitive modeling of enterprise applications. It abstracts application services such as persistence, tier'ing and messaging within the modeling language and enables a developer to focus more on the application domain. We discuss how we use DASL to model an application in the RFID domain, test for its correctness and proceed to deploy thus bringing about substantial efficiencies in the application development lifecycle.

Quality of a conceptual model can be defined along three dimensions - syntax, semantics and pragmatic. Pragmatic quality has been improved in the literature through schema transformations. We suggest an approach that also improves the semantic quality by schema transformations. A semantic quality parameter 'extent of normalization' is defined. Based on this parameter and functional dependencies from problem domain, a set of rules is suggested to improve a given conceptual model. We also show that relational schema produced after these transformations is normalized up to 3NF at least.

This poster presents <sc>MonitorMethod</sc> which helps Java programmers gain insight in the behavior of their applications. <sc>MonitorMethod</sc> instruments the Java application and relates hardware performance monitors (HPMs) to the methods in the Java application's source code. We present a detailed case study showing that linking microprocessor-level performance characteristics to the source code is helpful for identifying performance bottlenecks and their causes. In addition, we relate our work to a previously proposed time-based HPM profiling framework.

Mobile phones have been closed environments until recent years. The change brought by open platform technologies such as the Symbian operating system and Java technologies has opened up a significant business opportunity for anyone to develop application software such as games for mobile terminals. However, developing mobile applications is currently a challenging task due to the specific demands and technical constraints of mobile development. Furthermore, at the moment very little is known about the suitability of the different development processes for mobile application development. Due to these issues, we have developed an agile development approach called Mobile-D. The Mobile-D approach is briefly outlined here and the experiences gained from four case studies are discussed.

Distributed software systems are the basis for many innovative applications. The key for achieving scalable and maintainable distributed systems is dependability, because otherwise the complexity of distribution would leave the system uncontrollable. Hence, our approach aims at a concept for optimizing dependability. Similar to other approaches we use replication as means to provide transparent fault-tolerance and persistence, but we especially focus on increasing availability by relaxing data integrity by using a mixture of asynchronous and synchronous replication techniques. This work contributes three main aspects: First, a description of the envisioned trade-off between availability and consistency, secondly with a mechanism to achieve this trade-off, and thirdly, with models that use this mechanism and can be transparently deployed by developers. This work aims at enabling a configurable and application-specific optimum of availability, possibly even controlled during runtime. A real-life telecommunication application serves as proof of concept.

This paper outlines our project to help beginners learn to program by showing object visualisations driven by aspect- oriented programming, and presented as part of the Eclipse development platform. The aspect-oriented programming is part of the infrastructure we use to drive the visualisations that help students learn object-oriented programming. Aspect-oriented programming explicitly supports the kind of cross-cutting concerns that allows our system to drive visualisations that emphasise principles of object interaction. Our extensions to Eclipse allow us to provide this educational scaffolding to help learners, without altering the program, the programming language or the libraries.

There are a number of technologies designed to improve modularity in software systems. The technique presented here combines two of them seamlessly to exploit their respective benefits: Eclipse plugins and AspectJ. The Eclipse runtime is based on the idea of plugins, enabling large systems to be built from smaller components. AspectJ is an AOP-enhanced version of the Java language that allows developers to modularize crosscutting concerns into aspects. While both technologies offer a number of interesting features, their seamless combination is not trivial. Several limitations make it impossible to exploit all the features of the combined technologies. AspectJ-Enabled Eclipse Runtime (AJEER) is designed to overcome these limitations. It integrates load-time weaving for AspectJ into the Eclipse runtime, thus allowing developers to implement aspects that modularize crosscutting concerns beyond the capability of individual plugins. In addition, the dynamic features of the OSGi-based Eclipse 3.0 runtime are preserved in this setting - making it possible to plug AspectJ aspects into and out of the running system dynamically.

To accommodate the growing demand for complexity in the automotive industry, an approach for a cross-process information model is introduced: the infrastructure presented aims at storing and relating key development data from the various software engineering phases. The model can be harmonized with proprietary development methodologies by means of metamodeling and serves as the starting point for the traceability of requirements, global plausibility checks, and (semi-)automatic transformation of model elements. Based on the <i>medini</i> tool chain, the model infrastructure is open with respect to the models and tools used thanks to the consistent deployment of OMG standards and the benefit of metamodeling.

The use of design patterns in the mainstream has been limited due technical restrictions in supporting tools. We developed an integrated tool that supports language and platform independence, and facilitates cross-platform interoperability. The tool also assists in coding and design validating for quality assurance.

In previous work, we have shown that multicodes can be used to improve the performance of Java applications. We extend that work by both implementing more multicodes and considering multicodes of greater length. This has resulted in significantly larger performance gains than those that have been achieved previously for some benchmarks.

Our poster shows how J2EE technologies, well-known design patterns and standard methodologies have successfully been applied in building a complete, robust and well-documented accounting application. Our experience demonstrates that those three factors allow for easy maintenance and reuse of components. The application, whose development was initially outsourced, is now maintained by a CNR internal group and other Public Administrations have shown interest in adopting some of its components.

The poster tells, in brief, the story of the application from the planning phase to the latest developments.

<i>Meta</i> is an ambitious research project whose overall purpose is to increase the utility and expressive power of a wide range of existing languages. <i>Meta</i> provides augmented versions of existing languages and guarantees support for aspects, components, language interoperability, visualization, reflection, various inheritance models, and many other extensions.

Service Oriented Computing is the new paradigm for Distributed computing and e-business processing that is changing the way software applications are designed, architected, delivered and consumed. Services are autonomous platform-independent computational elements that can be described, published, discovered, orchestrated and programmed using standard protocols for the purpose of building agile networks of collaborating business applications distributed within and across organizational boundaries. Engineering and modeling service-oriented architectures need extensions to existing modeling techniques and methodologies. In this paper, we propose a UML profile for service-oriented architectures.

Externalization of application logic from application objects has become pervasive in its use in many system, business and application components. Implementation of such systems typically focuses on the use of rules and rule engines, and has typically been closely integrated with the application objects themselves and application source code needs to be modified to include decision points to externalize the logic. This puts a burden on the developers if the application contains a large number of decision points. The problem is compounded by legacy applications where source code is not available and therefore it is virtually impossible to modify the application source code to include the decision points. This has limited the potential use of application logic externalization methodology. In this report, we will describe an approach and tools to automate the process of externalizing application logic for applications without modifying source code.

Design by Contract (DBC) and runtime enforcement of program assertions enables the construction of more robust software. It also enables the assignment of blame in error reporting. As of yet, no AOP implementation for the provision of DBC exists. We present an aspect-oriented DBC tool for Java named <i>Cona</i>. We also extend the use of DBC and assertions to AOP. Aspects are used in the implementation of contracts, and contracts are used for enforcing assertions on aspects.

Despite being laden with elaborate features and time-saving gadgetry, modern Integrated Development Environments (IDEs) continue to be little more than turbocharged text editors with loosely integrated compilers. Years of incremental evolution of these environments have created a species of large, lumbering, often incomprehensible products with little direct support for the day-to-day tasks that developers actually find themselves doing.

In our poster we outline a fresh tool platform - development of which is well under way - which defines a revolutionary new environment for software development. Program editing is considered first and foremost as a direct manipulation of a rich semantic model whose persistent representation as plain-text source code is somewhere between conveniently incidental and almost entirely irrelevant.

We propose a new component-extraction-based program search system. Our system analyses existing Java programs, acquires relationships among classes, and extracts JavaBeans components composed of classes. Moreover, our system generates indexes composed of divided type names and comments for newly extracted components. Using our system, the extracted components can be searched by keywords, and the result set can be viewed by a web browser such that the user can decide whether the query result component matches his/her requirements.

In this paper we present aspect-oriented programming laws that are useful for deriving refactorings for AspectJ. The laws help developers to verify if the transformations they define preserve behavior. We illustrate that by deriving several AspectJ refactorings. We also show that our laws are useful for restructuring two Java applications with the aim of using aspects to modularize common crosscutting concerns.

We have replicated the experiments of Cecchet et al detailed in "Performance and Scalability of EJB Applications" at OOPSLA '02. We report on our experiences configuring, deploying and tuning Enterprise software, and provide evidence that many of the conclusions of the original work are misleading or cannot be generalized.

We investigate the use of mobile agents for the creation of music within a distributed computing environment. We believe this technology has the potential to foster new ways of making music. This poster presents Andante, an object-oriented, open-source infrastructure for building distributed musical applications based on mobile agents.

Our calculus combines class-based features with object-based ones, with the aim of fitting into a unified setting the "best of both worlds". In a mixin-based approach, mixins are seen as <i>incomplete classes</i> from which <i>incomplete objects</i> can be instantiated. Incomplete objects can be completed in an object-based fashion.

Code instrumentation is a mechanism that allows modules of programs to be completely rewritten at runtime. With the advent of virtual machines, this type of functionality is becoming more and more interesting because it allows the introduction of new functionality after an application has been deployed, easy implementation of aspect-oriented programming, performing security verifications, dynamic software upgrading, among others.

The Runtime Assembly Instrumentation Library (RAIL) is one of the first frameworks to implement code instrumentation in the.NET platform. It specifically addresses the limitations that exist between the reflection capabilities of.NET and its code emission functionalities. RAIL gives the programmer an object-oriented vision of the code of an application, allowing assemblies, modules, classes, references and even intermediate code to be easily manipulated.

This paper addresses the design of an implementation of RAIL along with the difficulties and lessons learnt in building a framework for code instrumentation in.NET.

Manual large-scale modification or generation of source code can be tedious and error-prone. Integrating scriptable source-to-source program transformations into development environments will assist developers with this overwhelming task. We discuss various usability issues of bringing such a<i>d-hoc</i> transformations to end-users and describe a developer-oriented interactive source code transformation tool for Java that we are building.

This paper describes a Software Agent called WSAgent, which combines technologies such as Web Services, Frameworks and Design Patterns in the construction of a bind to grant interoperability, reuse and flexibility between heterogeneous environments in the health domain.

AOP is often perceived as a second class reflective mechanism, whereas reflection in OOP is considered first class. However, perceiving AOP as a first class language mechanism is conductive to developing a general AOP model, which can be a basis for an overall theory of AOP. We illustrate this view by comparing AOP with reflection and illustrating that both mechanisms are conceptually at the same level.

This paper describe a model-driven development (MDD) toolsuite called <i>Component Synthesis using Model-Integrated Computing</i> (CoSMIC), which configures and deploys distributed real-time and embedded (DRE) systems using quality of service (QoS)-enabled component middleware. We show how CoSMIC addresses crosscutting configuration and deployment concerns at multiple layers of middleware and applications in component-based DRE systems. We also discuss how CoSMIC leverages model checking and analysis tools to validate key properties for configured DRE systems.

In work to date, domain analysis methods do not explicitly emphasize stability. In this poster, we present the <i>SODA</i> (Stability-Oriented Domain Analysis) method, a domain analysis method that embraces stability as a driver for domain analysis. We give an overview and an example of the method.

During the course of its evolution, software is modified through models at different levels of abstraction, from the requirements specification to source code. To enable systematic development and maintenance, related models need to be kept synchronized. In order to establish and maintain consistency, we need to precisely define what it means for two models to be synchronized. In this paper, we present our view of model synchronization as a problem of maximizing model dependencies. Our conceptual view of software models is as graphs, and model transformations are viewed in terms of basic graph transformations such as node insertions and deletions. Based on this view, a set of transformations applied to one model is traced and propagated to the other by choosing, from a set of possible transformation paths, a path that maximizes underlying model dependencies.

As bases for object-orientation, both class-based and prototype-based organization have limitations. We argue that roles have significant benefits as a foundation for organizing objects. We further argue that these benefits can be realised most flexibly using logic meta-programming. Additional benefits from this approach are to reduce redundancy and subsume aspects.

Jive represents a novel approach to runtime visualization and analysis of Java programs. It facilitates program understanding and interactive debugging, featuring: multiple, customizable views of object structure; representation of execution history via sequence diagrams; interactive queries on runtime behavior; forward and reverse interactive execution. JIVE uses standard JVM and compilers.

Software architecture is a distinct and developing discipline in the software profession. Many practitioners have apparently entered the field with little effort; adding the word "architect" to a title is easy to do. However, beneath the surface appearance, distinct approaches and toolsets are required to succeed. Reports of IT overspending and project failures emphasize the fact that these skills must be leveraged and developed. The practical application of this growing body of knowledge will continue to play an important role in the maturing of our profession, and its ability to deliver effective solutions. The software architect possesses a unique perspective and mental framework that guides the development of software systems. Additionally, strong interpersonal skills are vital to the software architect's success. In this paper, I explore the unique approaches and characteristics of the successful software architect.

Mock Objects is an extension to Test-Driven Development that supports good Object-Oriented design by guiding the discovery of a coherent system of types within a code base. It turns out to be less interesting as a technique for isolating tests from third-party libraries than is widely thought. This paper describes the process of using Mock Objects with an extended example and reports best and worst practices gained from experience of applying the process. It also introduces jMock, a Java framework that embodies our collective experience.

There appears to be a real dichotomy in the use of the UML vs. text based Use Case development for requirements elicitation and documentation, that is, on those projects where use cases are work products. Not only are there different processes in place for text and graphical use case modeling, but also there are a variety of approaches and philosophies in each camp. This paper will discuss the prose vs. graphical approaches to requirements elicitation, observed advantages and disadvantages of each, and suggest best practices for improving and/or creating effective processes for requirements elicitation.

As a small start-up company with a heavyweight client list, Sabrix found itself at a critical crossroads in its growth in the Spring of 2003. We were consuming all product development resources satisfying commitments made to existing customers, which seriously limited our ability to react to new requirements and improve our competitive edge in the market. In the face of this resource strain, we needed to add a series of smaller, plug-in type products to our existing offering. Of course, this environment required 100% focus on day-to-day tasks and tactical issues, leaving no time or energy for looking ahead.

Compounding these problems were the same issues that every company faces. A lack of trust between functional groups, with Product Development on one side and Sales and Support on the other; and, very few people in the company knew what work was being done in Product Development. When stepping back from the situation, we realized that all of the problems could be grouped into three general categories - prioritization, collaboration and visibility.

To improve each of these areas, we developed the Product Input and Planning (PIP) process. PIP is a cross-functional, cross-product way of building a roadmap by prioritizing work, balancing competitiveness and customer-driven requirements, and improving product-related communication in all directions within the company. The PIP Team is responsible for prioritizing and building an 18-month roadmap, focusing on the future direction of the company, while Product Management and Product Development focus on delivering the current releases.

This paper is not what one would call a success story, though it unquestionably has a moral. The PIP process as described herein exists no longer. Several factors contributed to its morphing into a different kind of family. The lessons learned over the course of the lifetime of PIP, however, are applicable to almost any large-scale, cross-functional endeavor.

This Report discusses how a web-based application development project adopted XP and passed its first ISO audit. The practitioners report will consist of background material, a discussion of XP-friendly practices that the development team adopted, a discussion of how ISO-friendly practices were incorporated, and a summary of the results of the ISO audit.

This practitioner report stems from a project, ANI's Digital Archive System. The report focuses on the benefits derived from a decision to ignore the popular wisdom of acquiring one of the many commercial-off-the-shelf (COTS) systems and build a document management system in-house instead. The approach, building on the existing set of object-oriented systems, provided the benefits of more specific features and total lower cost.

In the domain of hard real-time systems, which language is better: C++ or the Real-Time Specification for Java (RTSJ)? Although standard Java provides a more productive programming environment than C++ due to automatic memory management, that benefit does not apply to RTSJ when using NoHeapRealtimeThread and non-heap memory areas. As a result, RTSJ programmers must manage non-heap memory explicitly. Although that's a common practice in real-time applications, it's also a common source of programmer error, regardless of language. In an ironic role reversal, this paper shows that C++ is able to provide a safer programming environment than RTSJ (or C) for managing memory in a hard-real-time producer/consumer pattern. C++ accomplishes this via a reference-counting pointer. RTSJ (and C) cannot provide an equivalent mechanism because it lacks the necessary language features. Despite other attractive features of RTSJ, the relative simplicity and safety of the C++ programming model for this common pattern suggests that C++ will be a strong competitor to RTSJ in the domain of real-time mission-critical systems.

This paper reports our experiences using traits, collections of pure methods designed to promote reuse and understandability in object-oriented programs. Traits had previously been used to refactor the Smalltalk collection hierarchy, but only by the creators of traits themselves. This experience report represents the first independent test of these language features. Murphy-Hill implemented a substantialmulti-class data structure called ropes that makes significant use of traits. We found that traits improved understandability and reduced the number of methods that needed to be written by 46%.

Effective and affordable business process integration is a key concern in the finance industry. A large German joint-use centre, supplying services to 237 individual savings banks, enhanced the integration capabilities of its core banking system, consisting of more than 500 complex functions, through aggressive use of Web services.

Advanced requirements such as heterogeneous client environment, sub-second response times, 300% traffic growth, and interface complexity did challenge today's Web services implementations. To achieve true interoperability between Microsoft (MS) Office^™/.NET^™ and Java^™, and to implement more than 500 Web service providers in a short time frame were two of the most important issues that had to be solved. The current, second release of this solution complies with the Web Services Interoperability (WS-I) Basic Profile 1.0. Leveraging the Basic Profile reduced the development and testing efforts significantly.

This report discusses the rationale behind the decision for Web services, and gives an architectural overview of the integration approach. Furthermore, it features the lessons learned and best practices identified during the design, implementation and rollout of the solution.

In 1994 Wells Fargo Bank was the first large financial services company to invest heavily in distributed object-oriented applications for high-volume, mission-critical applications using version 1 of OMG's Common Object Request Broker Architecture. Wells Fargo continued to improve upon its distributed applications technology leadership by launching a Model Driven Architecture [MDA] initiative in 1999. The technology provided a consistent middle-tier for retail applications such as the award-winning Wells Internet Bank and various phone-bank applications.

Between 2001 and 2003 the original CORBA-based solution was completely replaced with new Web-Services-based distributed applications. This report contrasts the past and the present approach to such applications and discusses the lessons learned while transitioning from CORBA-based "Service Oriented Architecture" to one based on Web-Services.

The final section of this report utilizes lessons learned from using CORBA & Web-Services for Intranet applications and proposes the "application transparent distribution" as a potential paradigm shift which may lead to radically faster and more efficient distributed application development.

Frameworks are widely used to facilitate software reuse and accelerate development time. However, there are currently no systematic mechanisms to enforce the explicit and implicit rules of these frameworks. This paper focuses on a class of framework rules that place restrictions on the properties of data structures in framework applications. We present a mechanism to enforce these rules by the use of a generic "bad store template" which can be customized for different rule instances. We demonstrate the use of this template to validate specific bad store rules within J2EE framework applications. Violations of these rules cause subtle defects which manifest themselves at runtime as data loss, data corruption, or race conditions. Our algorithm to detect "bad stores" is implemented in the Smart Analysis-Based Error Reduction (SABER) validation tool, where we pay special attention to facilitating problem understanding and remediation, by providing detailed problem explanations. We present experimental results on four commercially deployed e-commerce applications that show over 200 "bad stores".

Runtime verification is a special form of runtime testing, employing formal methods and languages. In this work, we utilize next-time free linear-time temporal logic (LTL\textbackslash X) as formal framework. The discipline serves the purpose of asserting certain design-time assumptions about object-oriented (OO) entities such as objects, methods, and so forth. In this paper we propose a linear-time logic over joinpoints \citeLaddad03AspectJ, and introduce a lightweight runtime veri\-fication tool based on this logic, J2SE 5 metadata \citeJSR175 and an AspectJ-based \citeAspectJ runtime backend. Implementations have been proposed so far for imperative and functional languages \citeHuchStolz04a. To our knowledge our approach is the first to allow addressing of entire sets of states, also over subclass boundaries, thus exploiting the OO nature.

Many branches of engineering and science rely on graphs for representing a wide variety of objects from electrical circuits to economic systems. It is therefore reasonable to have a framework for constructing this kind of applications that can manage a graph structure. Nebras Graph Management Framework (NGMF) is a layered client-server framework for rapid development of these applications. This framework allows developers to construct different applications that deal with a network of nodes and edges. For example a CASE tool that handles UML class diagrams, a subject manager (an application for business entity classification) or a system for managing hierarchal lists of all product components (Bill Of Materials or BOM) are some cases that can be designed through applying our proposed framework.

Model-Driven Software Development (MDSD) techniques are being adopted with more frequency in the engineering of computer based systems, especially in the area of distributed real-time embedded (DRE) systems. This brief summary presents two research objectives for supporting software evolution in MDSD. First, the concept of model-driven program transformation is introduced to support evolution of large legacy software systems. The second research objective that is presented involves the application of a mature program transformation engine to automate model interpreter evolution in the presence of meta-model schema changes.

We propose a framework for removing redundant context management services in contextual composition frameworks, with focus on Enterprise JavaBeans. It is expected that by applying our framework, performance can be improved without the loss of modularity.

A long-standing goal of software engineering is to construct software that is easily modified and extended. Recent advances in software design techniques, such as aspect-oriented software development and refactoring, have offered new approaches to address challenges of software evolution. Several tools and language extensions have been developed by others to enable these techniques in a few popular programming languages. However, software exists in a variety of languages. An unfortunate consequence of legacy system adaptation is that new software engineering tools are often developed from scratch without preserving and reusing the knowledge gained from the previous construction of the tool in a different language and platform context. To address this problem, this paper summarizes two core research ideas. First, the concept of extending several software reengineering techniques in disparate programming languages is explored. A core focus of this objective is the abstraction of transformation functions to enable design maintenance in legacy based systems. The second research objective extends the first goal to understand the fundamental science for constructing a generic platform using grammar adapters to enable language-independent software maintenance.

Component-based enterprise systems often suffer from performance issues as a result of poor system design. In this paper, we propose a framework to automatically detect, assess and visualize poor system design, from a performance perspective, by analyzing run-time data using data mining techniques.

For the MDA approach to software development to become a reality for distributed enterprise systems, MDA needs to provide both modeling support for middleware-specific concerns and tool support for helping developers refine their designs along such concern-dimensions at different MDA-levels of abstraction. In order to address these issues, the MDA-compliant Enterprise Fondue method proposes a hierarchy of UML profiles as a means for addressing middleware-specific concerns at different MDA-levels of abstraction, along with model transformations to incrementally refine existing design models according to the proposed profiles. Tool support is provided through the Parallax framework, which enables developers to modularize crosscutting concerns into aspect-promoting Eclipse plug-ins.

A novel method for identifying dense communities of classes (clusters) within an Object-Oriented system has been developed. Such communities might possibly imply relevance of functionality and thus be used as Reusable Components. The term "Reusable Components" is used to refer to a set of interrelated classes that represent a module that can be used in different software systems. To accomplish this identification we employ Algebraic Graph Theory (Spectral Graph Partitioning Techniques). From a modified class diagram of the software system we create a graph in which classes stand for the nodes and the discrete messages exchanged between the classes stand for the edges. Our approach is based on an iterative method for partitioning the graph in order to identify possible reusable components within the system. The eigenvectors of the Laplacian matrix derived from the graph are used for the partitioning.

Common and special test inputs can be created to exercise some common and special behavior of the class under test, respectively. Although manually created tests are valuable, programmers often overlook some special test inputs. If programmers write down specifications, special or common tests can be automatically generated and selected by tools. However, specifications are not commonly written in practice. This research develops a novel approach for automatically identifying common and special unit tests for a class without requiring any specification. Given a class, our approach automatically generates test inputs and identifies common and special tests among the generated tests. Programmers can inspect these identified tests and use them to augment existing (manual) tests. Our approach is based on statistical algebraic abstractions, program properties (in the form of algebraic specifications) dynamically inferred from test executions. We use statistical algebraic abstractions to characterize program behavior. A test is identified to be common if the test exercises a behavior that is universally or commonly exercised by generated tests, or to be special if the test violates a behavior that is commonly exercised by generated tests.

In the present work, we outline a reverse engineering approach for UML specifications in form of class diagrams from Java bytecode. After a brief introduction to the subject we present some analyses which go beyond mere enumeration of methods and fields. A glance onto some related work shows that there seems to be no pat solution for the reverse engineering of the more difficult class diagram elements.

We sketch our method of determining association multiplicities, being, in a sense, representative of our approach in general: "intuitive" analyses, producing results that can be understood by a programmer when inspecting the source code of a given class.

Finally, we introduce a tool that implements this work and we apply it onto a small real life example, discussing the results it gave.

Extreme Programming (XP) is an agile software development methodology composed of several practices that purportedly yield high quality and high customer satisfaction. However, there has been little formal investigation of these claims. We conduct empirical, industrial case studies to evaluate XP. Results from two case studies are presented.