 |
| Home | · | Schedule | · | Tracks | · | Recommendations | · | Registration |
Sunday
Monday
Tuesday
Wednesday
Thursday
Wednesday, 29 October
Posters on displayMonday, 27 October – 17:30-19:30Tuesday, 28 October – 10:00-17:00Wednesday, 29 October – 10:00-17:00Thursday, 30 October – 10:00-14:00 |
Workshop on Process Engineering for Object-Oriented and Component-Based DevelopmentBrian Henderson-Sellers, University of Technology, Sydney, brian@it.uts.edu.au The poster will describe the results of the OOPSLA workshop on this topic |
Workshop: Second International Workshop on Agent-Oriented MethodologiesBrian Henderson-Sellers, University of Technology, Sydney, brian@it.uts.edu.au The poster will describe the results of the OOPSLA workshop on this topic |
The Twelfth OOPSLA Workshop on behavioral semantics -- Striving for SimplicityHaim Kilov,
Independent Consultant and Stevens Institute of Technology,
haimk@acm.org Elegant OO specifications of business and system semantics |
Visualizing Class Interfaces with Concept LatticesUri Dekel,
ISRI, School of Computer Science, Carnegie Mellon University,
udekel@cs.cmu.edu Our research promotes the use of a mathematical concept lattice based upon the binary relation of accesses between methods and fields as a novel visualization of individual Java classes. We demonstrate in a detailed real-life case study that such a lattice is valuable for reverse-engineering purposes, in that it helps reason about the interface and structure of the class and find errors in the absence of source code. We also show that this lattice can be of assistance in selecting an efficient reading order for the source code, if available. Our technique can also serve as a heuristic for automatic feature categorization, enabling it to assist efforts of re-documentation. |
Time Conscious Objects: A Domain-Specific Framework and GeneratorJorn Bettin,
SoftMetaWare,
jorn.bettin@softmetaware.com Time is a crosscutting concern that is hard to separate from other business logic. We have developed Time Conscious Objects (TCO), a Java toolkit that allows existing business application systems to be extended with "time conscious" behavior by factoring out all aspects of time-related behavior into a framework and a set of classes that is distinct from the existing code base. |
Middleware Benchmarking: Approaches, Results, ExperiencePetr Tuma,
Charles University, Czech Republic,
petr.tuma@mff.cuni.cz The poster presents results of the OOPSLA 2003 Workshop on Middleware Benchmarking. The workshop is a meeting point between developers and users as two groups involved in middleware benchmarking. The poster identifies the obstacles encountered when designing, running and evaluating middleware benchmarks and proposes approaches to tackle these obstacles. |
Visualization of EclipseChris Laffra, IBM Ottawa Labs, Chris_Laffra@ca.ibm.com The Eclipse platform uses plugins and an extension mechanism to manage complexity. This leads to hundreds or even thousands of plugins. Bytecode instrumentation can be used to visualize all these plugins. We show plugin activity and communication, plugin memory usage, detailed method tracing facilities, and custom visualizations. |
An Introduction to Fly: A Smaller SmalltalkThomas Wrensch,
University of the Pacific, Department of Computer Science,
twrensch@uop.edu Fly is a lightweight version of the Smalltalk programming environment. Fly attempts to preserve the benefits of Smalltalk as a development system while making it feasible to develop applications for embedded systems, PDAs, and other limited resource environments. Here we introduce the Fly project and its current and expected results. |
Generative Model Transformer: An Open Source MDA Tool InitiativeJorn Bettin,
SoftMetaWare,
jorn.bettin@softmetaware.com The Generative Model Transformer (GMT) project is an Open Source initiative to build a Model Driven Architecture tool. The project should result in (a) a tool that fulfils the MDA promise for faster/more accurate/better maintainable application development, (b) a tool for industrial use, and (c) MDA related research. A distinctive feature of GMT is the emphasis of model transformations as "first-class model citizens". |
Dynamic Personal Roles for Ubiquitous ComputingRobert McGrath,
Department of Computer Science, University of Illinois at Urbana-Champaign,
mcgrath@ncsa.uiuc.edu This paper presents doctoral research on a key problem for ubiquitous computing: implementation of representatives for physical objects, particularly people. This poster outlines an approach to implementing dynamic personal roles suitable for a ubiquitous computing environment. |
Implications of Test-Driven Development: A Pilot StudyReid Kaufmann,
Sun Microsystems, Inc.,
reid.kaufmann@sun.com A Spring 2003 experiment examines the claims that test-driven development or test-first programming improves software quality and programmer confidence. The results indicate support for these claims and inform larger future experiments. |
Agile Software Development for Component Based Software EngineeringWolfgang Radinger,
Vienna University of Technology, Institute of Computer Technology,
radinger@ict.tuwien.ac.at Agile Software Development and Component Based Software Engineering are two fundamentally different methods to serve today's demands of software engineering. By combining the technical and organizational issues, we introduce an approach for a consequent integration to allow agile component development in the small and system engineering in the large, respectively. |
Dynamically Updatable Component-based SystemRobert Bialek, DIKU, University of Copenhagen, bialek@diku.dk Updating 24/7/365 distributed, component-based applications is challenging. We present a framework of a Dynamically Updatable Component-based System (DUCS) and some of its implementation details. The framework is a multi-layered extension to now-a-days VirtualMachines supporting updates of heterogenous components. Prototype is a distributed GroupWare application build on top of the framework. |
MAS: A Multi-Agent System Modeling LanguageViviane Silva,
Pontifical Catholic University,
viviane@inf.puc-rio.br We propose a multi-agent system modeling language (MAS-ML) that extends UML based on structural and dynamic properties presented in a conceptual framework called TAO (Taming Agents and Objects). The main difference between our approach and the others is the clear definition and representation of the elements that compose multi-agent systems. |
*J: A Tool for Dynamic Analysis of Java ProgramsBruno Dufour,
McGill University,
bdufou1@cs.mcgill.ca We describe a complete system for gathering, computing and presenting dynamic metrics from Java programs. The system itself was motivated from our real goals in understanding program behaviour as compiler/runtime developers, and so solves a number of practical and difficult problems related to metric gathering and analysis. |
Beyond Green-Field Software Development: Strategies for Reengineering and EvolutionDennis Mancl,
Lucent Technologies, Murray Hill, NJ,
mancl@lucent.com This poster will be a report of the results of the workshop of the same title. The workshop addresses two important situations in the creation and evolution of long-lived software systems: how to renew an old software system and how to manage a software system that demands constant change and growth. In both situations, it is a challenge to manage the evolution process. The workshop will discuss a set of techniques and tools for software evolution that can contribute to success. |
Engineering and Reusing Stable Atomic Knowledge (SAK) patternsHaitham Hamza,
University of Nebraska-Lincoln,
hhamza@cse.unl.edu Reusing domain-independent knowledge might be hindered if such knowledge is presented as an integral part of domain specific components. This poster presents the concept of Stable Atomic Knowledge (SAK) patterns. A SAK pattern presents a domain-independent knowledge in such a way that makes this knowledge reusable whenever it is needed. |
Extracting Domain-Specific and Domain-Independent PatternsHaitham Hamza,
University of Nebraska-Lincoln,
hhamza@cse.unl.edu There are no mature guidelines or methodologies exist for extracting patterns. Software Stability Model can provide a base for extracting patterns. This poster presents the concept of extracting both domain-specific and domain- independent patterns from systems that are built using software stability concepts. |
An Approach to Monitor Application States for Self-Managing (Autonomic) SystemsHoi Chan,
IBM T.J Watson Research Center, IBM Corp.,
hychan@us.ibm.com Monitoring the states of an application is an important part of building applications with self-managing behaviors. The problem lies on those applications where no source code is available to add monitoring functions, or modification is expensive. In this report, we will describe an Aspect Oriented Programming based approach to build generic monitoring systems for legacy applications |
The "Killer Examples" for Design Patterns and Objects First workshops held at OOPSLA 2002 and 2003Carl Alphonce,
University at Buffalo, SUNY,
alphonce@cse.buffalo.edu A killer app is an "application that actually makes a sustaining market for a promising but under-utilized technology." [The Jargon File] A "killer example" provides clear and compelling motivation for some concept. This poster reports on OOPSLA2002 and OOPSLA2003 workshops exploring "killer examples" for teaching design patterns and objects-first. |
Patterns in RetrospectivesLinda Rising,
Independent consultant,
risingl@acm.org Retrospectives are important, not only for object technology, but for any human activity. Our workshop will begin documenting patterns for retrospectives and proposing an initial pattern language structure. The poster will present the skeleton outline of the fledgling pattern language and the patterns that will have been presented. |
Model Driven Architecture Development Approach for Pervasive ComputingKai Hemme-Unger,
DaimlerChrysler,
kai.hemme-unger@web.de The evaluation of a model driven architecture development approach on the project derived from the need to shorten the time-to-market and to improve the software quality. This seems to be reachable by applying application knowledge ex post to afore implemented building blocks. |
A Framework to Enable User Directed Component Binding at Run-TimeTimothy Troup,
University of Glasgow,
troup@dcs.gla.ac.uk Currently experimental scientists must perform time consuming and error-prone tasks to drive a series of computational data analyses. We have designed and implemented a novel framework that obviates the need for these tasks to be performed by enabling user directed component binding at run-time. |
Using Language Interpreters as Tools for Learning Different Programming ParadigmsArlindo da Conceicao,
University of São Paulo, Brazil,
arlindo@ime.usp.br We present a framework for implementing educational language interpreters. The architecture of the system was planned to highlight paradigm similarities and differences and also to offer clean object-oriented design. The framework includes classes to implement the functional (including closures and delayed evaluation), object-oriented, and logic programming paradigms. |
The Third OOPSLA Workshop on Domain-Specific ModelingJeff Gray,
University of Alabama at Birmingham (UAB),
gray@cis.uab.edu This poster describes a framework for implementing domain-specific visual modeling languages and summarizes industrial experiences from the use of domain-specific languages. The results of the Third OOPSLA Workshop on Domain-Specific Modeling will also be reported in this poster. |
Teaching Software Testing: Automatic Grading Meets Test-First CodingStephen Edwards, Virginia Tech, Dept. of Computer Science, edwards@cs.vt.edu A new approach to teaching software testing is proposed: students use test-driven development on programming assignments, and an automated grading tool assesses their testing performance and provides feedback. The basics of the approach, screenshots of the system, and a discussion of industrial tool use for grading Java programs are discussed. |
Modular Quality of Service-enabled Management Service for Component-based Distributed SystemsOctavian Ciuhandu,
Performance Engineering Laboratory,
ciuhandu@eeng.dcu.ie We present a modular QoS-enabled load management framework for component oriented middleware. It offers the possibility of selecting the optimal load distribution algorithms and changing the load metrics at runtime. The QoS service level agreements are made at user level, transparent to the managed application. According to the complexity of the managed application, only some of the modules might be required, thus activated. |
An AspectJ-Enabled Eclipse Core RuntimeMartin Lippert, University of Hamburg & it-Workplace Solutions Ltd., lippert@acm.org The poster shows the ideas and techniques behind a combination of the world of Eclipse plugins and AspectJ, for example implementing logging as a separated plugin. Load-time weaving techniques integrated into the Eclipse runtime allow the development of aspects that modularize crosscutting concerns across plugin boundaries. |
MRI Visual Analyzer: a comparative study of different analysis and design modeling methodsElham Yavari,
Graduate student, College of Engineering, San José State University,
e_yavari@yahoo.com In order to show the importance of analysis and design methods, we chose a problem statement (MRI visual analyzer) and developed two class diagrams based: traditional OO and software stability methods (SSM). Qualitative comparison between the two model shows that SSM improves the model simplicity, completeness and stability. |
A Proposed Framework for the Provision of e-Learning in ProgrammingMarie-Helene Ng Cheong Vee, Birkbeck College, University of London, gngch01@dcs.bbk.ac.uk We present a proposed framework for the provision of e-learning in programming and teaching programming irrespective of paradigm and language. The framework, consisting of set of integrated components provides course management, collaborative learning, an Intelligent Tutoring System, and computer-assisted creation of re-usable Learning Objects - all in the context of the Inverse Curriculum. |
Metamodeling Approach to Model TransformationsSheena Judson,
Louisiana State University,
sheena.judson@att.net Model Driven Architecture (MDA), which supports the development of software-intensive systems through the transformation of models to executable components and applications, requires a standard way to express transformations. This poster describes an approach based on rigorous modeling of well-defined pattern-based model transformations at the metamodel level. |
Multicodes: Optimizing Virtual Machines using Bytecode SequencesBen Stephenson,
The University of Western Ontario,
ben@csd.uwo.ca A virtual machine optimization technique that makes use of bytecode sequences is introduced. The process of determining candidate sequences is discussed and performance gains achieved when applied to a Java interpreter are presented. The suitability of this optimization for JVMs that perform just-in-time compilation is also discussed. |
Distributed Object Inheritance to Structure Distributed ApplicationsJessie Dedecker,
Vrije Universiteit Brussel,
jededeck@vub.ac.be Prototype-based languages (PBLs) are good at sharing information between objects, while sharing is a ubiquitous problem in distributed application programming (due to concurrency and partial failures). New language concepts can exploit the advantages of PBLs to ease the distribution problems and help express distributed communication patterns. |
2 Smart Play-OutTuesday, 28 October – 11:00-11:45Wednesday, 29 October – 12:00-12:45 |
This demo shows Smart Play-Out, a new method for executing and analyzing scenario based behavior, which is part of the Play-In/Play-Out methodology and the Play-Engine tool. Behavior is "played in" directly from the system's GUI, and as this is being done the play-engine continuously constructs Live Sequence Charts (LSCs), a powerful extension of sequence diagrams. Later behavior can be "played out" freely from the GUI, and the tool executes the LSCs directly, thus driving the system's behavior.
Smart Play-Out, a recent strengthening of the play-out mechanism, uses verification methods, mainly model-checking, to execute and analyze the LSCs, helping the execution to avoid deadlocks and violations. Thus, Smart Play-Out utilizes verification techniques to run programs, rather than to verify them.
Our approach is especially useful for specifying reactive object-oriented systems, and the LSC language we use has been extended to distinguish between objects and classes and to allow specifying of symbolic scenarios that hold for all object instances of a certain class.
In the demo we will show and explain the tool, illustrating the approach on several applications we have studied, including a phone network, a machine for manufacturing smart-cards and a model of a biological system.
As a long-term goal, for certain kinds of systems the play-out methodology, enhanced by formal verification techniques, could serve as the final implementation too, with the play-out being all that is needed for running the system itself.
23 AspectJ Development ToolsTuesday, 28 October – 11:00-11:45Wednesday, 29 October – 12:00-12:45 |
AspectJ™ is a seamless aspect-oriented programming extension to Java™. It can be used to cleanly modularize the crosscutting structure of concerns such as exception handling, multi-object protocols, synchronization, performance optimizations, and resource sharing. When implemented in a non-aspect-oriented fashion, the code for these concerns typically becomes spread out across entire programs. AspectJ controls such code-tangling and makes the underlying concerns more apparent, making programs easier to develop and maintain.
The updated AspectJ development tools suite and Eclipse plug-in will be used to demonstrate new tool features including incremental building, bytecode weaving, crosscutting structure views, and debugger support. Some common crosscutting concerns of an existing object-oriented system will be mined and refactored into a modular aspect-oriented implementation. The integration of AspectJ into existing development processes will also be reviewed along with JBuilder®, NetBeans, Emacs, and command-line tool support. Installation of the tools and project setup will demonstrate how easily AspectJ can be applied to existing Java systems.
4 Automated Impact Analysis of Objected Oriented SoftwareTuesday, 28 October – 12:00-12:45Wednesday, 29 October – 15:00-15:45 |
Comparative Impact Analysis (CIA) and Predictive Impact Analysis (PIA) are two methods of determining change/modification impact analysis on object-oriented software systems. JFlex, an object- oriented software tool, implements CIA and PIA for Java systems. With JFlex, software maintainers gain immediate knowledge of complex relationships in Java systems such as inheritance and aggregation by using the Extended Low-Level Software Architecture (ELLSA) model. The ELLSA model is built by examining the Java system’s source code. The demonstration will show how JFlex allows maintainers to create the ELLSA of a Java system, perform maintenance activities on the system, and then create a second ELLSA of the system and compare this to the first in order to determine changed components and ripple effect impacts resulting from the maintenance activities (CIA). The demonstration will also show how JFlex can be used to predict ripple effect impacts on an unmodified Java system by creating the ELLSA for the system and allowing the maintainer to ask “what if” questions pertaining to possible changes to the Java system. The resulting analysis helps maintainers to determine testing requirements and which other components must be changed as a result of the proposed modifications. JFlex is implemented in C++ under Microsoft Windows using MFC to construct the GUI. Keywords Object-Oriented Impact Analysis Object-Oriented Maintenance Object-Oriented Software Architecture
6 Hardware/Software Codesign For Neo SmalltalkTuesday, 28 October – 12:00-12:45Wednesday, 29 October – 16:00-16:45 |
The processors normally used for low cost or embedded applications are not well suited for running Smalltalk, so we created our own using programmable circuits (FPGAs). By creating the software and hardware specifically to work with each other it was possible to simplify both to such a degree that the resulting system is competitive in terms of price/performance compared to solutions with traditional processors, despite the inefficiency of FPGAs relative to custom designs. Both a 16 bit and a 32 bit hardware implementation of Neo Smalltalk will be shown in order to illustrate the cost and performance tradeoffs possible in this kind of development. The hardware is defined in terms of objects exchanging messages down to the lowest level, which is an interesting contrast to the traditional bytecoded virtual machines used for Smalltalk, Java and similar languages. Since the programming environment was designed to graphically show all implementation details, the audience will be able to see the issues mentioned above during a demonstration of the normal operation of the two Neo Smalltalk machines.
8 QuickUML: a tool to support iterative design and code developmentTuesday, 28 October – 12:00-12:45Wednesday, 29 October – 16:00-16:45 |
We demonstrate QuickUML, a freely available tool which supports iterative design and code development by providing facilities to draw UML class diagrams, to generate Java code from such diagrams, and also to automatically generate a UML class diagram from a collection of Java source code files.
We developed the tool for use by students in our introductory object-oriented courses. We found existing tools inappropriate due to slow graphics and complex user interfaces. QuickUML is now used in several courses from freshman to senior level.
The demonstration will show QuickUML's various features, including how to draw diagrams, how to generate code from diagrams and how to generate a diagram Java source code. The ability to move between source code and diagrams facilitates the use of an iterative design-and-code software development process.
Our experience is that when students have a tool which allows them to easily express their designs at a high level and frees them from the tedium of repeatedly coding fundamental relationships they begin to think of coding in terms of the higher-level constructs. This in turn allows us to focus more on issues of object-oriented design and less on issues of syntax.
Educators or trainers teaching or using object-orientation in their courses can use QuickUML to support iterative design-and-code development.
9 The Generic Modeling EnvironmentTuesday, 28 October – 12:00-12:45Wednesday, 29 October – 16:00-16:45 |
The Generic Modeling Environment (GME) is a metaprogrammable, domain specific, graphical editor supporting the design, analysis and synthesis of complex, software-intensive systems. It is closely related to metaCASE tools such as MetaEdit+ or Dome. Over a decade of research in model integrated computing has led to the development of GME. The toolset has been applied to modeling and synthesizing several real world applications for both government and industry organizations.
GME has an architecture based on MS COM technology and is implemented in C++. The Core component exposes the domain-specific language specification through a set of COM interfaces. It has another set of interfaces for model access. All the other components, (GUI, browser, OCL constraint manager, software generators, etc.) are built independently around the Core. Model persistence is supported via standard database technology and XML persistence. The technologies applied throughout GME (UML, OCL, COM, XML) make it easily applicable and extensible.
The demonstration will focus on using GME to develop an integrated simulation framework for embedded systems. The UML and OCL based metamodels specifying the domain-specific visual modeling language will be examined. We'll demonstrate how the domain-specific environment is automatically generated from these metamodels. We'll emphasize how the target visual language supports such OO concepts as type inheritance and multiple aspects. The automatic extension of the model access interface will be shown. This interface makes extensive use of OO techniques such as inheritance. We'll show an example application, including its complex models and the automatically synthesized simulation and C code.
5 JPie: An Environment for Live Software Construction in JavaTuesday, 28 October – 15:00-15:45Wednesday, 29 October – 15:00-15:45 |
JPie is a tightly integrated development environment supporting live object-oriented software construction in Java. JPie embodies the notion of a dynamic class whose signature and implementation can be modified at run time, with changes taking effect immediately upon existing instances of the class. The result is complete elimination of the edit-compile-test cycle. Dynamic classes are precompiled and then execute in a semi-interpreted manner using an internal representation of the dynamic portions of the class definition. Dynamic classes fully interoperate with compiled classes. Consequently, JPie users have access to the entire Java API, may create dynamic classes that extend compiled classes, and can override their methods on the fly. Instances of compiled classes may hold type-safe references to instances of dynamic classes, and may call methods on them polymorphically. All of these capabilities are achieved without modification of the language or virtual machine. JPie users create and modify class definitions through direct manipulation of visual representations of program abstractions. The visual representations expose the Java execution model, while removing the possibility of syntax errors and enabling immediate type-checking feedback. In this demonstration, we will illustrate the central features of JPie in the course of constructing an example application. These will include dynamic declaration of instance variables and methods, dynamic modification of method bodies and threads, dynamic user interface construction and event handling, and on-the-fly exception handling in JPie's integrated thread-oriented debugger.
Seven Paradoxes of Object-Oriented Programming LanguagesWednesday, 29 October – 8:30-10:00 |
 |
Although many of us have worked to create good object-oriented programming languages, it would be hard to say (with a straight face) that any of our creations have totally succeeded. Why not? I believe that this endeavor is essentially paradoxical. Thus, whenever a language designer pursues a particular goal and loses sight of the lurking paradox, the outcome is an all too often fatally flawed result. One way to think about this is to explore the following seven paradoxes:
- Because programming languages, development environments, and execution engines are intended for both people and computers, they must both humanize and dehumanize us.
- Adding a richer set of concepts to a programming language impoverishes its universe of discourse.
- Putting a language's cognitive center in a more dynamic place reduces the verbiage needed to accomplish a task, even though less information can be mechanically deduced about the program.
- The most concrete notions are the most abstract, and pursuing comfort or correctness with precision leads to fuzziness.
- Although a language, environment, and execution engine are designed for the users' minds, the experience of use will alter the users' minds.
- Object-oriented programming has its roots in modeling and reuse, yet these notions do not coincide and even conflict with each other.
- A language designed to give programmers what they want may initially succeed but create pernicious problems as it catches on. However, a language designed to give programmers what they really need may never catch fire at all.
Many of these assertions seem nonsensical, misguided, or just plain wrong. Yet, a deeper understanding of these paradoxes can point the way to better designs for object-oriented programming languages.
Technical Papers and Onward!: Error RepairWednesday, 29 October – 10:30-12:00 |
11:30 - 12:00 |
Automatic Detection and Repair of Errors in Data StructuresBrian Demsky,
MIT Laboratory for Computer Science,
bdemsky@mit.edu
We present a system that accepts a specification of key data structure constraints, then dynamically detects and repairs violations of these constraints, enabling the program to continue to execute productively even in the face of otherwise crippling errors. Our experience using our system indicates that the specifications are relatively easy to develop once one understands the data structures. Furthermore, for our set of benchmark applications, our system can effectively repair errors to deliver consistent data structures that allow the program to continue to operate successfully within its designed operating envelope. |
|---|
GenericsWednesday, 29 October – 10:30-12:00 |
10:30 - 11:00 |
A First-Class Approach to GenericityEric Allen,
Rice University,
eallen@cs.rice.edu
This paper describes how to add first class generic types—including mixins—to strongly-typed, object-oriented languages with nominal (name-based) subtyping such as Java and C#. A generic type system is "first-class" if generic types can appear in any context where conventional types can appear. In this context, a mixin is simply a generic class that extends one its type parameters, e.g., a class C<T> that extends T. Although mixins of this form are widely used in C++ (via templates), they are clumsy and error-prone because C++ treats mixins as macros, forcing each mixin instantiation to be separately compiled and type-checked. The abstraction embodied in a mixin is never separately analyzed. Our formulation of mixins using first class genericity accommodates sound local (class-by-class) type checking, in the same sense that Java supports local (class-by-class) compilation. A mixin can be fully type-checked given symbol tables for each of the classes that it directly references—the same context in which Java performs incremental class compilation. To our knowledge no previous formal analysis of first-class genericity in languages with nominal type systems has been conducted, which is surprising because nominal type systems have become predominant in mainstream object-oriented programming languages. What makes our treatment of first class genericity particularly interesting and important is the fact that it can be added to the existing Java language without any change to the underlying Java Virtual Machine. Moreover, the extension is backward compatible with legacy Java source and class files. Although our discussion of a practical implementation strategy focuses on Java, the same scheme could be applied to other object-oriented languages such as C# or Eiffel that support incremental compilation, dynamic class loading, and a static type system with nominal subtyping. |
|---|---|
11:00 - 11:30 |
A Comparative Study of Language Support for Generic ProgrammingRonald Garcia,
Indiana University,
garcia@osl.iu.edu
Many modern programming languages support basic generic programming, sufficient to implement type-safe polymorphic containers. Some languages have moved beyond this basic support to a broader, more powerful interpretation of generic programming, and their extensions have proven valuable in practice. This paper reports on a comprehensive comparison of generics in six programming languages: C++, Standard ML, Haskell, Eiffel, Java (with its proposed generics extension), and Generic C#. By implementing a substantial example in each of these languages, we identify eight language features that support this broader view of generic programming. We find these features are necessary to avoid awkward designs, poor maintainability, unnecessary run-time checks, and painfully verbose code. As languages increasingly support generics, it is important that language designers understand the features necessary to provide powerful generics and that their absence causes serious difficulties for programmers. |
11:30 - 12:00 |
Lightweight Confinement for Featherweight JavaTian Zhao,
University of Wisconsin, Milwaukee,
tzhao@cs.uwm.edu
Confinement properties impose a structure on object graphs which can be used to enforce encapsulation— which is essential to certain program optimizations, to modular reasoning, and in many cases to software assurance. This paper formalizes the notion of confined type in the context of Featherweight Java. A static type system that mirrors the informal rules of Vitek and Bokopwski is proposed and proven sound. The definition of confined types is extended to confined instantiation of generic classes. Thus allowing for confined collection types in Java and for classes that can be confined post hoc. Confinement types rules are given for Generic Featherweight Java, and proven sound. |
Discipline and Practices of TDD (Test Driven Development)Wednesday, 29 October – 10:30-12:00 |
This panel brings together practitioners with experience in Agile and XP methodologies to discuss the approaches and benefits of applying Test Driven Development (TDD). The goal of TDD is clean code that works. The mantra of TDD is: write a test; make it run; and make it right. Open questions to be addressed by the panel include:
- How are TDD approaches to be applied to databases, GUIs, and distributed systems?
- What are the quantitative benchmarks that can demonstrate the value of TDD, and
- What are the best approaches to solve the ubiquitous issue of scalability?
Acceptability-Oriented ComputingWednesday, 29 October – 10:30-12:00 |
These papers talk about a new approach to constructing software systems in which the designer identifies key properties that the execution must satisfy to be acceptable to its users. The resulting system consists of layers of components enforcing the acceptability properties.
Acceptability-Oriented ComputingMartin Rinard, MIT, rinard@lcs.mit.edu
We propose a new approach to the construction of software systems. Instead of attempting to build a system that is as free of errors as possible, we instead propose that the designer identify key properties that the execution must satisfy to be acceptable to its users. The developer then augments the system with a layered set of components, each of which enforces one of the acceptability properties. The potential advantages of this approach include more flexible, resilient systems that recover from errors and behave acceptably across a wide range of operating environments, an appropriately prioritized investment of engineering resources, and reduced development costs because of the ability to productively incorporate unreliable components into the final software system and to use less skilled implementors in the development process. |
Automatic Detection and Repair of Errors in Data StructuresBrian Demsky,
MIT,
demsky@lcs.mit.edu
We present a system that accepts a specification of key data structure constraints, then dynamically detects and repairs violations of these constraints, enabling the program to continue to execute productively even in the face of otherwise crippling errors. Our experience using our system indicates that the specifications are relatively easy to develop once one understands the data structures. Furthermore, for our set of benchmark applications, our system can effectively repair errors to deliver consistent data structures that allow the program to continue to operate successfully within its designed operating envelope. |
VisionWednesday, 29 October – 10:30-12:00 |
10:30 - 11:00 |
Model Driven Development - The Case for Domain Oriented ProgrammingDave Thomas,
Bedarra Research Labs,
dave@bedarra.com In this paper, we offer an alternative vision for domain driven development (3D). Our approach is model driven and emphasizes the use of generic and specific domain oriented programming (DOP) languages. DOP uses strong specific languages, which directly incorporate domain abstractions, to allow knowledgeable end users to succinctly express their needs in the form of an application computation. Most domain driven development (3D) approaches and techniques are targeted at professional software engineers and computer scientists. We argue that DOP offers a promising alternative. Specifically we are focused on empowering application developers who have extensive domain knowledge as well as sound foundations in their professions, but may not be formally trained in computer science. We provide a brief survey of DOP experiences, which show that many of the best practices such as patterns, refactoring, and pair programming are naturally and ideally practiced in a MDD setting. We compare and contrast DOP with other popular approaches, most of which are deeply rooted in the OO community. Finally we highlight challenges and opportunities in the design and implementation of such languages. |
|---|---|
11:00 - 11:30 |
An End to End Domain Driven Developement FrameworkAditya Agrawal,
ISIS, Vanderbilt University,
aditya.agrawal@vanderbilt.edu This paper presents a comprehensive, domain-driven framework for development. It consists of a meta-programmable domain-specific modeling environment, and a model transformation and generation toolset based on graph transformations. The framework allows the creation of custom, domain-oriented programming environments that support end-user programmability. In addition, the framework could be considered an early, end-to-end implementation of the concepts advocated by the Model-Driven Architecture of OMG. |
11:30 - 12:00 |
Software Factories: Assembling Applications With Patterns, Models, Frameworks and ToolsJack J. Greenfield,
Microsoft, Visual Studio, Enterprise Frameworks And Tools,
jackgr@microsoft.com The confluence of component based development, model driven development and software product lines forms an approach to application development based on the concept of software factories. This approach promises greater gains in productivity and predictability than those produced by the incremental advances of recent memory, which have not kept pace with rapid innovation in platform technology. Focusing on development by assembly using domain specific languages, patterns, models, frameworks and tools, software factories make systematic reuse cost effective for many applications, enabling the formation of supply chains and opening the door to mass customization. |
17 Redeveloping a High-Performance Computing FrameWorkWednesday, 29 October – 11:00-11:45 |
The High-Performance Computing (HPC) FrameWork is an object-oriented system that is designed to allow users to develop and execute HPC codes on geographically distributed high-performance computer (HPC) systems. The architecture was developed to support a set of image processing applications but can adapt to additional HPC application domains. Over the last year, an initial implementation of the system has been redeveloped using emerging object-oriented technologies.
The FrameWork's Kerberos-based client authentication services, initially implemented in C++, were replaced by a Java Server Pages (JSP) approach, based on the Globus Toolkit. Using the Gateway Portal project software enables future development of Grid capabilities for the FrameWork and establishes it as a Grid portal for HPC applications. Most client functionality is C++ code invoked by JSP Java Beans.
An HPC code adaptor object has been significantly refactored following successful alpha testing of the FrameWork. Initially, we only supported simple parameters for each of the HPC codes and ignored diverse sets of outputs for each of the codes. Redeveloping objects for two of the HPC codes to address these issues required a lot of expertise and understanding of the code which proved expensive. The refactored code adaptor object allows developers to focus on their input and output requirements. Using an XML description of input parameters and HPC code outputs further reduces the programming effort required.
This demonstration will follow a processing request through the system and then discuss C++/JSP/Grid portal client implementation issues and illustrate our approach to developing the HPC code adaptor object.
Keywords: Globus Toolkit, Grid, Gateway Portal, Refactoring, CGI, JSP, XML, HPC, Kerberos, Java Beans
18 Do You Still Use a Database?Wednesday, 29 October – 11:00-11:45Thursday, 30 October – 12:00-12:45 |
This is the demo of Prevayler, the original free-software Prevalence layer for Java.
System Prevalence is transparent persistence and transparent replication of native business objects. Prevayler makes any old Java VM logically invulnerable for business objects without the need for pre or post-processing.
Queries run 3 to 4 orders of magnitude faster than using a database through JDBC even with the whole database cached locally in RAM.
DBMSs are the single most hampering force acting on the OO community. While they provide us with vital services, such as the babies born inside the Matrix, we are also pitifully atrophied by the restrictions they impose.
Instead of maiming our object design, Prevalence frees us to use the observer pattern among thousands of business objects or to run polymorphic queries on millions of them - some basic examples that would be way too slow, even on OO databases.
We are no longer restricted to the query language, algorithms and data-structures provided with our database.
Prevayler has been ported to several languages including Python, Perl, C#, Objective C, Ruby and a Smalltalk port by Kent Beck and friends.
Witness the transparent persistence and replication of an application running on Prevayler and discuss:
- The simple concepts that make it possible;
- The 350 lines of insanely refactored Prevayler source-code;
- The shortcomings of the technology;
- The adoption by the community.
Above all, you'll be able to shutdown your database and start using the full potential of OO.
Keywords: Prevalence, Persistence, Transparent.
20 Jazz: A Collaborative Application Development EnvironmentWednesday, 29 October – 11:00-11:45 |
Collaboration is vital in any team-based software development effort, and traditionally occurs in the source control repository or in applications outside the IDE (e.g. email, instant messaging). The Jazz project extends the IDE with collaborative capabilities, focusing on adding awareness, coordination, and communication among a small team of developers. Our goal is to provide easy, in-context, yet unobtrusive access to as much team information as possible. We demonstrate this in our prototype by contributing a number of collaborative plug-ins to the Eclipse Java development environment.
Teams and their members are shown with their online status and information on the activities they are engaged in. Each team has an associated group discussion board, one-to-one chats to discuss source code, and screen sharing facilities for joint debugging and code walkthroughs. Team members can define, assign, and relate activities, which include tasks and source control events, and these are automatically logged in the discussion board and linked with relevant source files. In addition to people-centered awareness, the Jazz project provides resource-centered awareness. Through decorators in the package explorer, a user can tell which files have been checked out, modified, and checked in. Markers next to code are used to indicate modifications, annotations, chats about a particular region of code, and associated activities.
Keywords: Eclipse, IDE, application development, integrated development environment, collaborative computing, collaborative software engineering, collaborative development environment, CSCW, groupware, Java
22 T++ : A Tool for Web Application Development with C++Wednesday, 29 October – 11:00-11:45 |
C++ is widely used in application development, and there is no consolidated engine for web application development in C++. This work demonstrates T++, a tool for using C++ in web application development.
T++ works like JSP does for JAVA, and looks like other web programming tools: special documents have markup content, like HTML, mixed with C++ source code, which is executed when an user requests that document.
The expected audience for this presentation are software developers interested in using C++ to develop web applications.
T++ itself, the internal engine, is object oriented. The programming interface is object oriented too: documents generates classes that extend a T++ standard class, and can define methods, attributes and other members.
T++ is a free software engine that brings together some different techniques to provide a highly usable, efficient and safe tool for web development. Those techniques include shared memory allocation for C++ objects and dynamic C++ class loading. Running T++ requires a GNU/Linux system, an Apache web server, and GNU Compiler Collection (gcc) with support to C++.
This demonstration will show the basics of web application development with T++, including how to set up the T++ engine, how to program with T++, and some web development techniques.
Keywords: Web application development, C++
24 Variant Management for Embedded Software Product Lines with Pure::Consul and AspectC++Wednesday, 29 October – 12:00-12:45Thursday, 30 October – 13:00-13:45 |
Software for embedded systems faces some special constraints not found in other domains. One of these constraints is a hard limitation on available RAM/ROM, processing power, and other resources. To cope with these limitations without losing the reusability of the software components, product line technologies are a promising approach. However, adequate tools for variant management are still rare.
In the demonstration we will apply Pure::Consul, a tool which supports the description of problem and solution domains of product lines, software families, or other variable artifacts in a highly flexible manner, to a realistic application scenario: a weather station product line running on a small 8 bit microcontroller with only a few KBytes of memory.
Problem domain modeling with Pure::Consul is based on extended feature models. The tool allows for integration of many different variability realization techniques through its customizable transformation backend. Thus, it is able to incorporate frame processors, code generators, or arbitrary other tools.
The implementation of the presented product line is based on AspectC++, an aspect-oriented extension to C++. We will demonstrate that by applying aspect-oriented software development, the number of configuration points in the code can be reduced. Both tools together form an ideal tool chain for embedded software product line development as one reduces the configuration complexity on the source code level, while the other helps to manage the variability on the abstract feature level and provides a mapping of features to aspects, classes, or other modularization units.
27 Visual SDLC: Improving Requirements Engineering for Object-Oriented SystemsWednesday, 29 October – 12:00-12:45Thursday, 30 October – 13:00-13:45 |
In theory, requirements engineering solves many of software engineering's fundamental problems. The stakeholders know what the developers are building, why they are building it, when they are building it, and even to some degree, how they are building it. If requirements engineering resolves some of the basic communication issues between IT and the business, why aren't more companies actively practicing this discipline? In practice, requirements engineering is almost impractical without a commercial automation tool. The critics argue that the current automation tools do not convincingly demonstrate its value proposition, or fulfill the longstanding promises of the leading requirements engineering experts. This paper describes how the enterprise software development lifecycle management solution, Visual SDLC, addresses some of the outstanding issues of the present requirements engineering tools.
44 Notes on the Forgotten Art of Software ArchitectureWednesday, 29 October – 13:30-17:00 Afternoon |
Quality software systems require quality software architectures. Otherwise it is hard, if not impossible, to meet their functional and non-functional requirements and to master their inherent complexity. For instance, software architectures for systems with end-to-end quality of service demands, systems with stringent security requirements, or systems that are supposed to be in operation for 20+ years cannot be created on the fly, using contemporary middleware and tools. Instead, these architectures must be crafted with care, following a defined specification process and making thoughtful design decisions.
This tutorial explores some of the timeless secrets of building high-quality software architectures, in terms of process, methodology, design goals, and architectural properties, to convey the foundations of building successful software.
Attendee background
Prerequisites: Participants must have experience with object-oriented software design and development.
Format
Lecture
Presenter
Frank Buschmann is senior principal engineer at Siemens Corporate Technology in Munich, Germany. His interests include Object Technology, Frameworks and Patterns. Frank has been involved in many software development projects. He is leading Siemens' pattern research activities. Frank is co-author of "Pattern-Oriented Software Architecture -- A System of Patterns" and "Pattern-Oriented Software Architecture -- Patterns for Concurrent and Networked Objects."
45 Test-Driven Development with "fit", the Framework for Integrated TestWednesday, 29 October – 13:30-17:00 Afternoon |
This tutorial introduces the Framework for Integrated Test (fit) and demonstrates its use in Test-Driven Development (TDD), as practiced in Extreme Programming and other agile development methods. Projects use fit-style tests both to guide programming and to test the correctness of the result. Test-driven designs are more easily "refactored," making it the only programming method that expects programs to get "cleaner" over time.
Short lectures will explain just enough of Extreme Programming to establish the context for test-driven design. These will be followed by live demonstrations and laboratory exercises. The labs will use simple Java, but the emphasis is on familiarity with the frameworks, tools and techniques, not programming. If you are unfamiliar with Java, you will learn enough just by watching to be able to complete some of the exercises and obtain all of the benefits of the tutorial.
Bring a laptop, or join someone who has one, to do hands-on exercises. Bring a wireless networking card to participate in additional "online" activities. Install Java at home to save time in class. Google "sun java download" to find a version for your computer.
Attendee background
Prerequisites: Some programming experience with an object-oriented language is required (not necessarily Java). Familiarity with downloading and installing software is also required.
Format
Lecture, demonstration, and optional exercises
Presenter
Ward Cunningham is a founder of Cunningham & Cunningham, Inc. He has served as Director of R&D at Wyatt Software and as Principle Engineer in the Tektronix Computer Research Laboratory. Ward is well known for his contributions to the developing practice of object-oriented programming, the variation called Extreme Programming, and the communities hosted by his WikiWikiWeb.
46 Object-Oriented Reengineering: Patterns & TechniquesWednesday, 29 October – 13:30-17:00 Afternoon |
Surprising as it may seem, many of the early adopters of the object-oriented paradigm already face a number of problems typically encountered in large-scale legacy systems. Software engineers are now confronted with millions of lines of code, developed using object-oriented design methods and languages of the late 80s and early 90s. These systems exhibit a range of problems, effectively preventing them from satisfying the evolving requirements imposed by their users.
This tutorial will share our knowledge concerning the reengineering of object-oriented legacy systems. We will draw upon our experiences with the FAMOOS project to show you techniques and tools we have used on real industrial OO systems to detect and repair problems. In particular, we will discuss approaches such as reverse engineering, design extraction, metrics, refactoring and program visualisation.
Attendee background
Prerequisites: Participants should have practical programming experience in at least one OO language (Smalltalk, C++, Java, Eiffel, etc.). Familiarity with UML is useful, though not required.
Format
Lecture
Presenters
Serge Demeyer is a professor in the Department of Mathematics and Computer Science at the University of Antwerp in Belgium. He leads a research group investigating software reengineering (LORE - Lab On REengineering). His main research interest concerns software engineering (more precisely, reengineering in an object-oriented context), but for historical reasons, he maintains a heavy interest in hypermedia systems as well. He is an active member of the corresponding international research communities, serving on various conference organizing and program committees.
Stéphane Ducasse is an assistant professor in the Software Composition Group at the University of Berne. He served as technical leader of the FAMOOS Esprit project, a project whose goal was to propose a set of reengineering techniques and tools to support the development of object-oriented frameworks. He is an expert in object-oriented programming, design patterns, framework development, reflective programming and component technology. He is one of the main designers of the MOOSE reengineering environment that is the basis for CodeCrawler, a program understanding tool. He is the main organizer of the annual European Smalltalk Advanced Seminars.
Oscar Nierstrasz is a Professor of Computer Science at the University of Berne, where he leads the Software Composition Group. He is the author of numerous publications on object-oriented and component-based technology. He has been active in the object-oriented research community for many years, serving on the programme committees of the ECOOP, OOPSLA and many other conferences.
47 Enterprise Application Integration with J2EE and .NETWednesday, 29 October – 13:30-17:00 Afternoon |
Creating enterprise-scale information systems poses many challenges, as such systems require integrating multiple (legacy) applications in such a way as to streamline and automate internal business processes and provide web-enabled business functions. The underlying architectures for such systems are embodied in a range of diverse products known as Enterprise Application Integration (EAI) technologies.
This tutorial introduces EAI. It highlights some of the major issues in EAI technology selection, application design, and deployment. It introduces service-oriented architectures as a means of EAI, and presents some common architecture patterns for accomplishing EAI using J2EE and .NET. J2EE components covered will include the Java Messaging Service, Java Connector Architecture and supporting application server technology. In .NET, BizTalk, Web Services and various XML technologies will be described and illustrated. We will conclude with a detailed comparison of the strengths and weaknesses of J2EE and .NET technologies for EAI.
Attendee background
Prerequisites: A solid understanding of object-oriented programming languages, such as Java, C++, or C#. Familiarity with the key features of distributed component technologies and enterprise platforms (e.g., J2EE, .NET) is useful but not required.
Format
Lecture and demonstrations
Presenters
Ian Gorton is chief architect in information sciences and engineering at the US Department of Energy's Pacific Northwest National Laboratory. His research interests include software architectures, particularly large-scale, high-performance information systems that use commercial off-the-shelf (COTS) middleware technologies. Dr. Gorton received a PhD in Computer Science from Sheffield Hallam University.
Anna Liu is an enterprise architect with Microsoft Australia. Her research interests include software architectures, patterns and best practices, and COTS software-evaluation and acquisition methods. Dr. Liu holds a BEng (with honors) and a PhD in computer engineering from the University of New South Wales, Australia.
48 Guided Inspection of UML ModelsWednesday, 29 October – 13:30-17:00 Afternoon |
There is widespread agreement that finding defects as early in the development life cycle as possible is cost effective; however, there are few systematic techniques for accomplishing this goal. Guided inspection is an inspection technique that is "guided" by test cases. By constructing a "complete" set of test cases, the guided inspection technique identifies elements missing from the model, and it also evaluates the quality of those that are present. This tutorial illustrates the technique using design models created using the Unified Modeling Language. Checklists designed for use at various points in a typical development process assist the inspector in selecting the most effective test cases.
Guided Inspection has several benefits:
- Objectivity - systematically selects test cases to give all portions of the model equal coverage.
- Traceability - links the faults detected back to specific requirements.
- Testability - identifies portions of the design that are complex and require much effort to test.
After taking this tutorial, participants will be able to:
- define test scenarios from use cases.
- apply these test cases to an actual system model.
- adapt the technique and checklists to the maturity of a specific model.
Attendee background
Prerequisites: Attendees should be familiar with UML. It will be helpful if attendees have participated in software reviews and inspections previously.
Format
Lecture and exercises
Presenter
Dr. John D. McGregor is a partner in Luminary Software and an associate professor of computer science at Clemson University. He conducts research, teaches graduate software engineering courses, and serves as a consultant to companies in several domains. Dr. McGregor has conducted research for organizations such as the Software Engineering Institute, National Science Foundation, DARPA, IBM and AT&T. He has applied those research results on projects in telecommunications, insurance, and financial institutions. He is co-author of "A Practical Guide to Testing Object-Oriented Software," published by Addison-Wesley. Dr. McGregor's current research interests include software product lines, design quality, testing and measurement.
49 Extending Enterprise Systems with Mobile/Wireless ApplicationsWednesday, 29 October – 13:30-17:00 Afternoon |
Many organizations are adding mobile and wireless capabilities to their IT infrastructure. This tutorial explores technologies, designs and issues associated with the development of mobile and wireless software applications. In this tutorial, we explore how to leverage and reuse existing object-oriented system code for mobile and wireless applications. We also identify the pros/cons and development issues associated with various software application solutions, including Java, .NET, Wireless Application Protocol (WAP), and Brew. We examine the device market and its impact on software development. Finally, we discuss what makes for good and bad mobile/wireless software. Not unlike enterprise software, mobile/wireless software solutions must be appropriately designed. Some of the design and architecture issues are shared with those of bigger object-oriented applications. Other issues, especially around user interface and database synchronization, require special consideration. This tutorial exposes the mobile/wireless software architecture and design issues and potential solutions.
Attendee background
This tutorial is targeted to those individuals exploring mobile/wireless software application development.
Prerequisites: Participants should have some familiarity with the basic concepts of software development and object-oriented programming.
Format
Lecture, examples, and demonstrations
Presenter
James White is Wireless Practice Manager and Senior Consultant for Fourth Generation, Inc. based in St. Paul, MN. He is the co-author of "Java 2 Micro Edition" from Manning Publications and has written several articles on mobile/wireless computing, Java and object-oriented topics. Jim also finds time to speak frequently at industry conferences and spoke about J2ME at last year's JavaOne conference.
50 Understanding Circa-2003 XML TechnologiesWednesday, 29 October – 13:30-17:00 Afternoon |
XML has grown out of the world of document management to become a broadly applicable technology that has impact on storage, messaging, and programming languages. This tutorial will look at the current landscape of XML technologies that are used to transmit, traverse, and transform XML-based information, with an emphasis on how these technologies impact current programming environments. Topics to be discussed include:
- The XML Data Model(s)
- Traversal: Imperative vs. Declarative
- Transformation and Projection: XSLT and XML Query
- Datatypes in XML: XML Schema Part II
- Structural types in XML: XML Schema Part 1, Relax NG
- XML Messaging: SOAP
- Behavioral typing in XML: Web Services
- Nominal typing in XML: RDF and WS-Policy
Attendee background
Attendees should have a basic familiarity with two or more type systems used in modern programming environments.
Format
Lecture
Presenter
Don Box is an architect on the XML Messaging team at Microsoft, where he works on defining and implementing the web service protocol stack. Don co-created the Simple Object Access Protocol (SOAP) and has helped develop SOAP-based technologies such as WS-Policy, WS-Reliable Messaging and WS-Addressing. Don has written several books on component technologies for Addison Wesley, beginning with "Essential COM," and most recently, "Essential .NET."
51 Designing Reliable CollaborationsWednesday, 29 October – 13:30-17:00 Afternoon |
Software need not be impervious to failure. But it shouldn't easily break. A large part of software design involves building our software to accommodate situations that, although unlikely, still have to be addressed. Once you've decided on the basic architecture of your system, assigned responsibilities to objects, and designed collaborations, you can take a closer look at making specific collaborations more reliable--by designing objects to detect and recover from exceptional conditions. This tutorial covers reliable collaboration design from A to Z. Topics include: resolving the mismatch between use case and program level exceptions, check-and-act and try-and-see exception recovery strategies, objects that are naturally suited for taking on exception-handling responsibilities, and how to streamline error checking by identifying trusted collaboration regions and designing for trusted and untrusted collaborations. We'll also present guidelines for naming exceptions and common exception-handling traps to avoid.
Attendee background
Prerequisites: Attendees should be familiar with object-oriented design and programming.
Format
Lecture with many examples, case studies, and guidelines based on real-world experiences and projects
Presenter
Rebecca Wirfs-Brock is a world-renowned innovator in practical object analysis and design techniques. She is lead author of the new book, "Object Design: Roles, Responsibilities and Collaborations" (Addison-Wesley 2003). She invented the set of development practices known as Responsibility-Driven Design. Most recently, she has focused on ways to effectively communicate design ideas, designing flexible software without over- or under-engineering a solution, and effective ways to think through design alternatives. Among her widely used innovations are use case conversations and object role stereotypes. She specializes in the transfer of object analysis and design expertise through mentoring, consulting, and training.
52 Agile Database Techniques: Data Doesn't Have To Be A Four Letter Word AnymoreWednesday, 29 October – 13:30-17:00 Afternoon |
Many modern object-oriented applications must manipulate data stored in relational databases (RDBs). There is a well-known technical impedance mismatch between the object-oriented and relational models that must be overcome to permit such integration. Equally important but less publicized, there is also a cultural impedance mismatch between OO developers and relational database professionals. If modern software development is to succeed, we need to find ways to overcome both mismatches.
This tutorial addresses both the technical and cultural impedance mismatches between object and relational technologies and practitioners. To address the technical mismatch, we discuss techniques that data professionals can follow to support agile software development efforts, including database refactoring, evolutionary data modeling following the practices of Agile Modeling using the UML, mapping techniques, object/relational database implementation strategies, and Test-Driven Development (TDD). To address the cultural mismatch, we describe the skills and knowledge that agile software developers need to gain over time to be effective with respect to data-oriented development activities.
Attendee background
Prerequisites: Attendees must have an understanding of the fundamentals of agile software development.
Format
Lecture
Presenter
Scott Ambler is a noted expert in data management and agile methods. He is author of several books, including "The Object Primer 3rd Ed.", "Agile Modeling," and "Agile Database Techniques."
Java PerformanceWednesday, 29 October – 13:30-15:00 |
13:30 - 14:00 |
Dynamic Metrics for JavaBruno Dufour,
McGill University,
bdufou1@cs.mcgill.ca
In order to perform meaningful experiments in optimizing compilation and run-time system design, researchers usually rely on a suite of benchmark programs of interest to the optimization technique under consideration. Programs are described as numeric, memory-intensive, concurrent, or object-oriented, based on a qualitative appraisal, in some cases with little justification. We believe it is beneficial to quantify the behavior of programs with a concise and precisely defined set of metrics, in order to make these intuitive notions of program behavior more concrete and subject to experimental validation. We therefore define a set of unambiguous, dynamic, robust and architecture-independent metrics that can be used to categorize programs according to their dynamic behavior in five areas: size, data structure, memory use, concurrency, and polymorphism. A framework computing some of these metrics for Java programs is presented along with specific results. |
|---|---|
14:00 - 14:30 |
How Java Programs Interact with Virtual Machines at the Microarchitectural LevelLieven Eeckhout,
Ghent University,
leeckhou@elis.rug.ac.be
Java workloads are becoming increasingly prominent on various platforms ranging from embedded systems, over general-purpose computers to high-end servers. Understanding the implications of all the aspects involved when running Java workloads, is thus extremely important during the design of a system that will run such workloads, to meet its design goals. In other words, understanding the interaction between the Java application, its input and the virtual machine it runs on, is key to a successful design. The goal of this paper is to study this complex interaction at the microarchitectural level, e.g., by analyzing the branch behavior, the cache behavior, etc. This is done by measuring a large number of performance characteristics using performance counters on an AMD K7 Duron microprocessor. These performance characteristics are measured for seven virtual machine configurations, and a collection of Java benchmarks with corresponding inputs coming from the SPECjvm98 benchmark suite, the SPECjbb2000 benchmark suite, the Java Grande Forum benchmark suite and an open-source raytracer, called Raja with 19 scene descriptions. This large amount of data is further analyzed using statistical data analysis techniques, namely principal components analysis and cluster analysis. These techniques provide useful insights in an understandable way. From our experiments, we conclude that (i) the behavior observed at the microarchitectural level is primarily determined by the virtual machine for small input sets, e.g., the SPECjvm98 s1 input set; (ii) the behavior can be quite different for various input sets, e.g., short-running versus long-running benchmarks; (iii) for long-running benchmarks with few hot spots, the behavior can be primarily determined by the Java program and not the virtual machine, i.e., all the virtual machines optimize the hot spots to similarly behaving native code; (iv) in general, the behavior of a Java application running on one virtual machine can be significantly different from running on another virtual machine. These conclusions warn researchers working on Java workloads to be careful when using a limited number of Java benchmarks or virtual machines since this might lead to biased conclusions. |
14:30 - 15:00 |
Effectiveness of Cross-Platform Optimizations for a Java Just-In-Time CompilerKazuaki Ishizaki,
IBM Research, Tokyo Research Laboratory,
ishizaki@trl.ibm.com
We describe the system overview of our Java JIT compiler, which has been the basis for the latest production version of IBM Java virtual machine that supports a diversity of processor architectures including both 32-bit and 64-bit modes, CISC, RISC, and VLIW architectures. In particular, we focus on the design and evaluation of the cross-platform optimizations that are common across different architectures. We study the effectiveness of each optimization by selectively disabling it in our JIT compiler on three different platforms: IA32, IA64, and PowerPC. Based on the detailed statistics, we classify our optimizations and identify a small set of the most cost-effective ones in terms of the performance improvement as the benefit and the compilation time as the cost. In summary, we demonstrate that, with a selected set of optimizations, we can achieve 90% of the peak performance for SPECjvm98 at the expense of only 33% of the total compilation time in comparison to the case in which all the optimizations are enabled. |
Innovate!Wednesday, 29 October – 13:30-15:00 |
Freedom to innovate is one of the key motivators for many technical workers. Unfortunately, although innovation is often trumpeted as a key company attribute, it seems that many organizations struggle to provide the necessary environment—even those organizations whose original claim to fame lay in their ability to innovate. This panel will look at the barriers to innovation that occur in a variety of environments: large, well-established organizations, start-ups, academia, standards bodies and the open source community. Panelists will propose a set of technical and non-technical techniques that can be used to foster innovation in even the most lethargic or hostile environment.
Old CodeWednesday, 29 October – 13:30-15:00 |
13:30 - 14:00 |
Using AspectJ for Component Integration in MiddlewareAdrian Colyer,
IBM UK,
adrian_colyer@uk.ibm.com
This report discusses experiences applying and enhancing AspectJ for a middleware product line at IBM. The purpose of this
effort was to apply Aspect Oriented Programming to cleanly separate components from their execution platforms, while still
allowing them to take advantage of platform-specific facilities for aspects such as error handling, performance monitoring,
and logging. It presents the evolution of the design, implementation, tools support, and approaches used to achieve organizational
buy in.
|
|---|---|
14:00 - 14:30 |
Five years of framework building: lessons learnedKurt Madsen, MetaTech, Inc., madsen@tampabay.rr.com When developing large software systems, it is often difficult to foresee exactly which trade-offs are important, and which quality parameters will be of importance down the road. This paper reports experiences from a project in which a large application framework for B2B integration has been continuously developed and used over a five year period. The framework has been the foundation for a variety of different concrete applications; here we will report on our experiences from this endeavor. |
14:30 - 15:00 |
Agile Regression Testing Using Record & PlaybackGerard Meszaros,
ClearStream Consulting,
gerard.meszaros@acm.org There are times when it is not practical to hand-script automated tests for an existing system before one starts to modify it (whether to refactor it to permit automated testing or to add new functionality). In these circumstances, the use of “record & playback” testing may be a viable alternative to hand-writing all the tests. This paper describes experiences using this approach and summarizes key learnings applicable to other projects. |
TechnologyWednesday, 29 October – 13:30-15:00 |
13:30 - 14:00 |
XAspects: An Extensible System for Domain-Specific Aspect LanguagesMacneil Shonle,
Northeastern University,
mshonle@ccs.neu.edu
Current general aspect-oriented programming solutions fall short of
helping the problem of separation of concerns for several concern
domains. Because of this limitation good solutions for these concern
domains do not get used and the opportunity to benefit from
separation of these concerns is missed. By using XAspects, a plug-in
mechanism for domain-specific aspect languages, separation of
concerns can be achieved at a level beyond what is possible for
object-oriented programming languages. As a result, XAspects allows
for certain domain-specific solutions to be used as easily as a new
language feature.
|
|---|---|
14:00 - 14:30 |
The Power of Symmetry: Unifying Inheritance and Generative ProgrammingDeLesley Hutchins, MZA Associates Corporation, hutchins@mza.com I present the Ohmu language, a unified object model which allows a number of "advanced" techniques such as aspects, mixin layers, parametric polymorphism, and generative components to be implemented cleanly using two basic concepts: block structure and inheritance. I argue that conventional ways of defining classes and objects have created artificial distinctions which limit their expressiveness. The Ohmu model unifies functions, classes, instances, templates, and even aspects into a single construct – the structure. Function calls, instantiation, aspect-weaving, and inheritance are likewise unified into a single operation – the structure transformation. This simplification eliminates the distinction between classes and instances, and between compile-time and run-time code. Instead of being compiled, programs are reduced using partial evaluation, in which the interpreter is invoked at compile-time. Within this architecture, standard OO inheritance becomes a natural vehicle for creating meta-programs and automatic code generators— the key to a number of recent domain-driven programming methodologies. |
14:30 - 15:00 |
Domain Driven Web Development With WebJinnSergei Kojarski,
Northeastern University,
kojarski@ccs.neu.edu
Web application development cuts across the HTTP protocol, the client-side presentation language (HTML, XML), the server-side technology (Servlets, JSP, ASP, PHP), and the underlying resource (files, database, information system). Consequently, web development concerns including functionality, presentation, control, and structure cross-cut, leading to tangled and scattered code that is hard to develop, maintain, and reuse. In this paper we analyze the cause, consequence, and remedy for this crosscutting. We distinguish between intra-crosscutting that results in code tangling and inter-crosscutting that results in code scattering. To resolve inter-crosscutting, we present a new web application development model named XP that introduces extension points as place-holders for structure-dependent code. We present another model named DDD that incorporates XP into the Model-View-Controller (MVC) model to resolve both intra- and inter-crosscutting. WebJinn is a novel domain-driven web development framework that implements the DDD model. WebJinn has been used to develop web applications at several web sites. Domain driven web development with WebJinn benefits from a significant improvement in code reuse, adaptability, and maintainability. |
3 Visualizing and AspectJ-enabling Eclipse Plugins using Bytecode InstrumentationWednesday, 29 October – 15:00-15:45Thursday, 30 October – 12:00-12:45 |
In the first part of this demonstration, we will use visualization techniques to show how Eclipse utilizes plugins and its extension mechanism to form a basic runtime infrastructure that allows the design and implementation of IDEs and general applications. We will show how bytecode manipulation techniques can be used to instrument all the classes in all the Eclipse jars and what possible visualizations can be the result. We will start with a bird's eye view and gradually dive down into the gory details. The goal of this exercise is to gain a better understanding of the inner workings of Eclipse and to address bugs and performance issues of given plugins.
In the second part of the demo, we will investigate aspect-oriented programming using AspectJ. We will show how one can combine the world of Eclipse plugins and AspectJ. One such example would be a logging aspect, implemented as a plugin. Using aspect techniques on Eclipse plugin jars, would allow for the development of aspects that modularize crosscutting concerns across plugin boundaries. We will present an enhanced version of the Eclipse Core Runtime Platform that integrates load-time weaving functionality of the AspectJ language into the platform.
Attendees of this demonstration will see the running systems and how they can be used. The implementation details of both the visualization techniques used in part 1 and the enhanced Eclipse Core Runtime discussed in part 2 will be described in detail.
21 Requirements Use case Tool (RUT)Wednesday, 29 October – 15:00-15:45Thursday, 30 October – 13:00-13:45 |
The Requirements Use case Tool (RUT) provides assistance to managers, customers, and developers in assessing the quality of use cases. In addition, RUT serves as a database repository for requirements developed as use cases. To ensure consistency, the tool provides a standard use case template to be used for all use case entry into the repository. Furthermore, RUT provides integration with Rational Rose, the industry-standard tool for developing UML diagrams. The tool also provides a series of metrics useful for calculating information about the relationships among the captured use cases. RUT performs use case evaluation by searching text and identifying risk indicators such as incomplete or weak phrases. The Requirements Use case Tool is a valuable resource for collecting, evaluating, and maintaining software requirements gathered as use cases.
RUT is a web-based, multi-user application that provides project team members with the ability to create, view, and modify use cases and related information for a particular project. The "dashboard" view provided by the tool gives managers and others the ability to quickly ascertain the status of a project by viewing various use case metrics. The tool was developed using multi-platform, open source technologies (PHP and MySQL).
All features of the Requirements Use case Tool described above will be demonstrated at the conference.
Language DesignWednesday, 29 October – 15:30-17:00 |
15:30 - 16:00 |
HydroJ: Object-Oriented Pattern Matching for Evolvable Distributed SystemsKeunwoo Lee,
University of Washington,
klee@cs.washington.edu
In an evolving software system, components must be able to change independently while remaining compatible with their peers. One obstacle to independent evolution is the brittle parameter problem}: the ability of two components to communicate can depend on a number of inessential details of the types, structure, and/or contents of the values communicated. If these details change, then the components can no longer communicate, even if the essential parts of the message remain unaffected. We present HydroJ, an extension of Java that addresses this problem. In HydroJ, components communicate using self-describing, semi-structured messages, and programmers use pattern matching to define the handling of messages. This design stems from two central ideas: first, that self-describing messages reduce dependence on inessential message format details; and second, that object-oriented pattern matching naturally focuses on the essential information in a message and is insensitive to inessential information. We have developed these ideas in the context of Rain, a distributed, heterogeneous messaging system for ubiquitous computing. To evaluate the design, we have constructed a prototype HydroJ compiler, implemented some Rain services in HydroJ, and formalized HydroJ's key features in a core language. |
|---|---|
16:00 - 16:30 |
Relaxed MultiJava: Balancing Extensibility and Modular TypecheckingTodd Millstein,
University of Washington,
todd@cs.washington.edu
We present the rationale, design, and implementation of Relaxed MultiJava (RMJ), a backward-compatible extension of Java that allows programmers to add new methods to existing classes and to write multimethods. Previous languages supporting these forms of extensibility either restrict their usage to a limited set of programming idioms that can be modularly typechecked (and modularly compiled) or simply forego modular typechecking altogether. In contrast, RMJ supports the new language features in a virtually unrestricted form while still providing modular static typechecking and compilation. In some cases, the RMJ compiler will warn that the potential for a type error exists, but it will still complete compilation. In that case, a custom class loader transparently performs load-time checking to verify that the potential error is never realized. RMJ's compiler and custom loader cooperate to keep load-time checking costs low. We report on our qualitative and quantitative experience with our implementation of RMJ. |
16:30 - 17:00 |
ModJava: A Rational Module System for Java and Its ApplicationsJohn Corwin,
IBM,
jcorwin@us.ibm.com
While Java provides many software engineering benefits, it lacks a coherent module system and instead provides only packages (which are primarily a name space mechanism) and classloaders (which are very low-level). As a result, large Java applications suffer from unexpected interactions between independent components, require complex CLASSPATH definitions, and are often extremely complex to install and maintain. We have implemented a module system for Java that is implemented with class loaders but provides a much higher-level interface. High-level properties can be specified in a module definition and are enforced by the module system as new modules are loaded. To experimentally validate the ability of ModJava to properly handle the complex module inter-relationships found in large Java server systems, we replaced the classloader mechanisms of Apache Tomcat 4.1.18 with 30 ModJava modules. The modified Tomcat is functionally identical to the original, but requires no CLASSPATH definitions, and will operate correctly even if user code loads a different version of a module used by Tomcat, such as the Xerces XML parser. Furthermore, by making a small change to the Java core libraries enabled by ModJava, we obtained a 30% performance improvement in a servlet microbenchmark. |
Model Driven Architecture: How far have we come, how far can we go?Wednesday, 29 October – 15:30-17:00 |
Model Driven Architecture (MDA) is a technology that has been in the process of evolution for many years. Today, many vendors are now producing products that support MDA. We are hearing more and more 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? Here is your opportunity to ask the experts the questions that are necessary to convince you of the validity of this new technology. Each of these panelists has been intricately involved in building the underlying foundations of Model Driven Architecture and its implementation.
Real-World ObjectsWednesday, 29 October – 15:30-17:00 |
15:30 - 16:00 |
Programming with Non-Heap Memory in RTSJGreg Bollella,
Sun Microsystems Laboratories
The Real-Time Specification for Java (RTSJ) provides facilities for deterministic, real-time execution in a language that is otherwise subject to variable latencies in memory allocation and garbage collection. In particular, RTSJ introduces two kinds of non-heap memory area (ScopedMemory and ImmortalMemory) and a kind of real-time thread (NoHeapRealtimeThread) that, together, can satisfy very demanding timeliness requirements because they run without interference from the garbage collector. What new RTSJ programmers quickly discover, though, is that the RTSJ "assignment rules"—governing references from one kind of memory to another—force designers to think more carefully about how data flows among the components of a system. In particular, for the hard real-time portions of a system, the normal Java practice of freely passing around references and letting the garbage collector recognize when an object is no longer needed simply doesn't apply. This report discusses two related design issues that all RTSJ users will face: how to explicitly manage non-heap memory and how to communicate information among components without violating RTSJ’s assignment rules. These issues are addressed from a practitioner’s viewpoint in the context of designing real-time control loops for driving and steering a 6-wheel Mars rover. The solution described here is termed “scoped memory scratchpads” and is believed to provide a good combination of Java-natural style and safety from programmer error. In this approach, transient data is allocated within a scoped memory area that is emptied later when all Runnables exeunt the memory area. Data that must be preserved across cyclic executions use memory pools, restricted so that all pool management is confined to a single component and is thus much easier to design and verify. Importantly, by maintaining a distinction between application-specific software and framework software, some of the details and discipline of using RTSJ can be hidden from application programmers. |
|---|---|
16:00 - 16:30 |
The Parks PDA: A Handheld Device for Theme Park Guests in SqueakYoshiki Ohshima,
Twin Sun, Inc.,
Yoshiki.Ohshima@acm.org
The Parks PDA is a lightweight, handheld device for theme park guests that functions as a combination guidebook, map, and digital camera. Together with a small team of artists and designers, we created a prototype Parks PDA and content for a three hour guest experience, including a camera interface, a hyper-linked guide book, three games, an animal spotters guide, a cross-referenced map, animated movies with lip-synched sound, a ride reservation system, and more. Over 800 visitors to Disney's Animal Kingdom theme park tested the Parks PDA over a two week period. Developing the software for this test posed a number of challenges. The processor and memory of the target device were slow, the screen was small, and we had only three months of development time. We attacked these problems using Squeak, a highly-portable, open source Smalltalk implementation. We ported Squeak to the target device and used it to provide nearly bit-identical behavior across four different platforms. This supported a cross-platform development style that streamlined the production of both software and content. We created a tiny user interface and application framework for pen-based devices and implemented a simple card-stack media editor and player using it. We isolated and fixed several performance problems. The project was completed on time and guest response was favorable. Looking back, we can identify ten aspects of Squeak that contributed to the success of the project. While we feel that Squeak was the ideal tool for this job, many of the key benefits of Squeak could be enjoyed using other object-oriented languages such as Java J2ME or Python, especially if the source code of the virtual machine is available. |
The Biology of InformationWednesday, 29 October – 15:30-17:00 |
Walter Fontana is a research professor in residence at the Santa Fe Institute, has served as a Member of the Institute for Advanced Study in Princeton, NJ, with the Program in Theoretical Biology, and was a member of the University of Vienna faculty at the Institute for Theoretical Chemistry and Molecular Structural Biology.
25 Building Compilers For Micro-programmable Graphics ProcessorsWednesday, 29 October – 16:00-16:45 |
Even with the continuing downturn in the economy, one market segment, which continues to thrive, is the entertainment market. The games market has now even surpassed the film industry's profits. Existing general-purpose processors have been steadily extended (SSE, 3Dnow, and Altivec) to better support the game industry. Custom graphics processors or GPUs have been available for a few years now and these graphics processors are slowly evolving to generalized stream processors. Recently, Microsoft, and 3D Labs (Open GL ARB) have developed virtual execution environments to abstract the underlying graphics processors. Additionally new languages including Cg, HLSL, and GLSlang have been developed to target these graphics virtual machines.
The objective of this demonstration is to illustrate the issues involved in targeting graphics processors. I will start with a concrete example of a high-end film style "special effect" and then illustrate how it can be written in both Pixar's Renderman Shading Language and Nvidia's Cg. I will then disassemble the code and illustrate how the Cg compiler generates vertex and pixel "shader" assembly language. Using the "special effect" as an example, how the domain specific "shading language" constructs are mapped to the underlying GPU data types and instructions will be explained in depth. Additionally, I plan to discuss what underlying hardware mechanisms are needed in the GPU instruction set in order to add object-oriented constructs to shading languages. Finally, I will conclude with a discussion on targeting object-oriented virtual machine technologies such as the JVM, Squeak and the CLI to graphics processors.
The Big EventWednesday, 29 October – 19:00-23:00 |
This reception is open to all conference registrants. This is an excellent forum to share information on the conference activities and network with conference participants; including speakers and authors. Join us for the final evening event for OOPSLA 2003.