 |
| Home | · | Schedule | · | Tracks | · | Recommendations | · | Registration |
Sunday
Monday
Tuesday
Wednesday
Thursday
Thursday, 30 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. |
7 Making reusable learning objects available through LOM and XMLTuesday, 28 October – 11:00-11:45Thursday, 30 October – 12:00-12:45 |
The norwegian ministry of education and research is currently establishing an education portal as part of the national learning net for the education sector. One major goal of this initiative is to enable better reuse and sharing of learning objects on the internet. The portal is developed by BEKK, a Norwegian consultancy.
The demonstration will show:
- An efficient and user friendly search interface optimised for learning resources
- Using the LOM standard to facilitate data integration
- Using loose coupling and XML to enable integration
The LOM (Learning Object Metadata) standard; IEEE 1484.12.1 (http://ltsc.ieee.org/wg12/) standard was approved December 10, 2002 and defines a meta-model to categorize and describe learning objects. Although well received, and internationally recognized, adoption is still in its early stages, which again required the project to define the actual use of the standard in collaboration with local standardization bodies.
The following technologies and products developed the portal and search interface:
- A portal framework; IBM Websphere Portal Server for the search user interface
- A search engine; Verity, to index the meta-data for learning objects
- XML and XML Schema for data interchange and validation
The demo will run on a standard web-browser; although designed to support all browsers; it is optimzed for a javascript enabled browser. The data interchange and internal processes can be displayed by a terminal emulator with SSH support, such as putty.
11 ATCT: a Java Framework that Offers New Approach to Developing Asynchronous ProcessesTuesday, 28 October – 15:00-15:45Thursday, 30 October – 11:00-11:45 |
Velare Technologies, Inc. will demonstrate ATCT (Asynchronous Transfer of Control Threading) – a Java framework for asynchronous method invocation. ATCT facilitates development of asynchronous long-running processes in Java, using well-known OOP techniques and design patterns. Traditionally when an application interacts asynchronously with an external environment, event-driven programming is used. However, this approach makes it difficult to develop processes with complex flow logic. Moreover, programming of sophisticated workflow patterns becomes almost impossible. ATCT allows transforming the event-driven programming style into a well-known sequential programming style, enabling the use of OOP for asynchronous process development. In addition, it is possible to develop a variety of new types of applications that require manipulation of execution context. ATCT introduces a new approach for execution context reification in Virtual Machine based runtime environments. ATCT uses a secondary bytecode interpreter to execute specially marked methods in a special mode, which allows to access execution context as first class object. The secondary interpreter is written in the Java programming language allowing use of ATCT on any JVM. ATCT’s functionality and capabilities will be presented by using slides and code samples. After introducing the concept using simple examples, we will show the possibilities for complex distributed architectures by showing prototypes of frameworks for messaging and web applications. Our demonstration is targeted to people who are interested in the use of VM-oriented mainstream OO languages such as Java or C#, for new types of applications. The demonstration should also be interesting for designers of Virtual Machines and new languages.
12 Generative Model TransformerTuesday, 28 October – 15:00-15:45Thursday, 30 October – 12:00-12:45 |
The Generative Model Transformer (GMT) project is an Open Source initiative to build a Model Driven Architecture™ tool that allows fully customisable Platform Independent Models, Platform Description Models, Mappings, and Refinement Transformations. The project should result in:
- a tool that fulfils the MDA promise for faster/more accurate/better maintainable application development,
- a tool for industrial use,
- MDA related research - which is encouraged and needed.
GMT resides as a technology project on Eclipse.org.
The demo intends to show the state of the tool at the time of OOPSLA.
The software is designed using UML modeling and implemented using generative techniques. It will be implemented mainly in Java. Links will be provided to other existing tools that can fill in some of the functionality required.
GMT will provide a related set of components that can be used by other MDA tool components, and will consist of four main components:
- A mapping component that can combine two XMI-encoded models into one new XMI-encoded model.
- A model transformation component using XMI as input and output.
- A text generation component, using XMI as input and text (code) as output.
- A workflow component that provides the required glue between the three functional components above, any additional user-developed MDA tool components, and popular IDEs/tool platforms such as Eclipse.
14 MetaEdit+: Defining and using domain-specific modeling languages and code generatorsTuesday, 28 October – 16:00-16:45Thursday, 30 October – 11:00-11:45 |
MetaEdit+ is an environment that allows building modeling tools and generators fitting to application domains, without having to write a single line of code. The capability to define modeling tools and generators is relevant as it provides the ability to raise the abstraction of design work from code to domain concepts, and a raise in abstraction leads to an imminent raise in productivity, as illustrated by the past years' experiences.
In domain-specific modeling and MetaEdit+, one expert defines a domain-specific language as a metamodel containing the domain concepts and rules, and specifies the mapping from that to code in a domain-specific code generator. For the method implementation, MetaEdit+ provides a metamodeling language and tool suite for defining the method concepts, their properties, associated rules, symbols, checking reports, and generators.
Once the expert defines a modeling method, or even a partial prototype, the rest of the team can start to use it in MetaEdit+ to make models with the modeling language and the required code is automatically generated from those models. Based on the metamodel, MetaEdit+ automatically provides CASE tool functionality: diagramming editors, browsers, generators, multi-user/project/platform support, etc. MetaEdit+ is implemented in Smalltalk.
The MetaEdit+ demo will focus on showing how the domain-specific languages and generators are made; complete with several examples of domain-specific methods and related code generators.
Keywords: metamodel; domain-specific modeling languages; code generators
15 A Policy Based System to Incorporate Self-Managing Behaviors in ApplicationsTuesday, 28 October – 16:00-16:45Thursday, 30 October – 11:00-11:45 |
With the rapid increase in complexity of software systems and applications, it becomes necessary to develop tools to simplify the incorporation of self-managing features into applications. The use of object and component technologies, together with a policy system which externalizes business logic from an application, plays an important role in enabling systems with greater manageability and variability.
Current policy systems are mainly domain specific, and there is a need for an execution system which is flexible and usable across a variety of domains. Our policy execution system provides a framework which utilizes object and component technologies to separate the process of executing a policy into various components and processes. Each component and sub-process can be developed independently, configured and reused.
In our programming system, an episode of policy execution can be viewed as a composition of the following components: high level policy language definition and authoring, translation to executable code for the choice of execution mechanism, input and output, mappings of application objects and the underlying execution mechanism (rule engines, execution algorithms or strategies). Furthermore, we separate a high level policy into its various logic components: operation logic, priority logic, conflict resolution logic and each of these components can be developed and reused independently.
Our policy framework completely hides the programming details and exposes the interfaces only. In the demo, we will show how to build an application using the policy framework in various contexts with a single policy and modify the policy subsequently to illustrate the various operation of each of the components and features, and how an application uses the policy system to enhance its self-managing features. (The prototype of this system will be available for free download in 3Q of 2003.)
16 Using Events to Debug Java Programs Backwards in TimeTuesday, 28 October – 16:00-16:45Thursday, 30 October – 11:00-11:45 |
An "Omniscient Debugger" works by recording all state changes in the run of a program, and then allowing the programmer to explore the history of that program— effectively going "backwards in time." Event analysis debuggers work by observing events as they occur, and allowing the programmer to write queries which will pause the program when matched.
Recently we have integrated the two techniques to produce an omniscient debugger which can use event queries to search the history of a program interactively. The query mechanism is designed along the lines of an EMACS incremental search.
The implementation of the system is in Java and records two types of events: method calls (and returns) and assignments. To our best knowledge, this is the first event model for Java.
A typical scenario is a quick sort program which neglects to sort one entry. An event search for the method call which should have sorted the entry ("Find a call to sort() whose start is less than the entry and whose end is greater") allows the programmer to get close to the bug, and the normal mechanisms of the omniscient debugger ("step forwards", "step backwards", etc.) allow the programmer to verify the exact cause of the bug.
In addition to the above (which the Prolog-based Coca system of Ducasse is capable of), it is possible to include both objects and the instance variables of those objects in the query (e.g., "Find a call to OBJ.sort() where OBJ.type is 'Integer'").
26 Time Conscious ObjectsTuesday, 28 October – 16:00-16:45Thursday, 30 October – 13:00-13:45 |
In most business software systems the time dimension of business objects plays a significant role. Time is a crosscutting concern that is hard to separate from other business logic. We have developed a toolkit that allows existing business application systems to be extended with "time-conscious" behavior in a non-intrusive way 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. The Time Conscious Objects™ (TCO) toolkit is currently implemented in Java™, but through the use of generation technology the toolkit can easily be made available in any language that supports polymorphism.
The TCO toolkit has been explicitly designed to allow non-intrusive and incremental integration into existing systems. Time-conscious objects can have a major impact on the quality and maintainability of applications by eliminating the complexity of dealing with the time dimension. This is the case for example in time-based billing systems, in the insurance industry, and in the modeling of "parts" in ERP and manufacturing systems.
The demonstration provides an overview of the architecture and the APIs that TCO uses to integrate with existing application system environments. Beyond that, the demonstration shows on the basis of one or more small example applications, how TCO can be used to raise the level of abstraction in platform independent models and in business application code.
TCO product development is work-in-progress and the demonstration is intended to be highly interactive, giving the audience opportunity to raise and discuss their specific time-dimension-related requirements.
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.
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.
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.
53 Legacy: The Other Kind of InheritanceThursday, 30 October – 8:30-12:00 Morning |
There it is. All that code. And you weren't responsible for its development. That fact alone is normally enough for most individuals to berate the code as flawed and unmanageable. But once past the reflex response, there may actually be a problem. Software that you didn't develop, and especially code that has evolved over a long period of time, is never a green field. The code itself is just the tip of an iceberg that includes history, politics, anthropology, and economics, but rarely any post-enlightenment reasoning.
How do you get your head around this stuff? How do you work with it? How do you move it forward without being so busy breaking eggs that you never have time to make the omelet? This tutorial takes a stroll through some of the issues plus some of the tips and tricks that might help out. There is no big vision and no technology sell. Indeed, one of the most significant pitfalls to be aware of is falling into the fashion trap, adopting the latest and greatest technology fad and declaring it to be the one true way forward. A succession of fashion parades is often responsible for putting some of the 'gac' into legacy.
Attendee background
This tutorial is targeted at programmers, managers, and other interested technical parties who find themselves working in or in contact with legacy code.
Format
Lecture
Presenter
Kevlin Henney is an independent consultant and trainer. The focus of his work is in programming languages, OO, CBD, UML, patterns, and software architecture. He is a regular columnist for C/C++ Users Journal (online), Application Development Advisor (UK), and JavaSpektrum (Germany), and previously wrote columns in Java Report and C++ Report. He is also a member of the advisory board for Hillside Europe, the program chair for EuroPLoP 2003, and a popular speaker at conferences in the US and Europe.
54 Running Agile Software Development Projects with RUPThursday, 30 October – 8:30-12:00 Morning |
The Rational Unified Process (RUP) is a comprehensive process covering almost all aspects of software development projects. Due to its great level of detail, RUP has--quite wrongly--the reputation of being too heavyweight for agile development projects. In this tutorial, you will learn how to configure RUP for agile development. Topics covered include what artifacts to use and not to use, best practices for planning and monitoring projects, best practices for handling requirements, analysis and design, and how to introduce agile RUP into a project or in an organization. About 25% of the time of the tutorial is devoted to a demonstration of a real world project which has been successfully completed with an agile version of RUP.
Attendee background
This tutorial is aimed at project managers, software architects, software process specialists and software developers who are evaluating RUP for agile development or who are involved in a project where RUP is already used and want to make it more agile. Knowledge of RUP basics is helpful but not required.
Format
Lecture and demonstration
Presenter
Michael Hirsch has 20 years of experience in the software industry in various roles, including project manager, software architect and software developer. During the last 10 years, he has been with Zühlke Engineering AG, a software contractor and software consultancy in Switzerland. He has been using RUP since 1998, when he led a team that introduced RUP at Zühlke Engineering and adapted it to the company's needs. Since then Zühlke Engineering has successfully completed about 20 projects with an agile version of RUP. Today, Michael splits his time between managing software development projects, coaching and mentoring project teams, and teaching classes on software processes and object oriented analysis and design. He is a member of ACM and IEEE, and has a degree in electrical engineering from HTL Bregenz in Austria and a degree in software engineering from HTL Berne in Switzerland.
55 J2EE in Practice: Architectural Variations in the Context of Enterprise SystemsThursday, 30 October – 8:30-12:00 Morning |
J2EE serves as a reference architecture for enterprise applications. It has gained widespread use over the past few years. For each part of a multi-tier enterprise application, J2EE provides both an implementation technology and a blueprint of how it should be used.
Unfortunately, it is not always easy determine which J2EE technology to use in a given context, or how to use it. This tutorial explores different architectural alternatives available to developers when working with J2EE and describes when it is and is not appropriate to use each one. These guidelines are taken from experiences using J2EE for real-world, mission-critical applications.
Attendee background
Prerequisites: Attendees should have some experience with using J2EE and possess a basic understanding of what the different constituents of J2EE are used for.
Format
Lecture and discussion
Presenters
Markus Völter works as a freelance consultant for software technology and engineering. He focuses on the architecture of large, distributed systems. Markus is the author of several magazine articles and patterns, a regular Speaker at Conferences and co-author of Wiley's "Server Component Patterns - Component Infrastructures illustrated with EJB."
Over the last couple of years, Markus has architected, coached and implemented on several J2EE systems in various domains (banking, diagnostics, automotive) and on various scales (ranging from 10 developers and 400 concurrent users up to 120 developers and 50,000 users).
Dr. Arne Koschel works world-wide as Technical Product Manager and Product Specialist for IONA's Orbix Application Server Platform (ASP). Previously, he worked as independent Senior Object Technology Consultant and Enterprise Software-Architect with assignments throughout Europe and the United States. One of his major involvements (system architecture) for an Online Brokerage Application was selected as the major JavaOne 2001 J2EE customer success story. He is a regular speaker at conferences world-wide and author of many publications. He also cooperates with Universities, where he teaches courses in the areas of middleware and active databases.
56 Model-Driven ArchitectureThursday, 30 October – 8:30-12:00 Morning |
Today, application development remains a laborious process, with relatively little reuse or automation. Application programmers must manually map their high-level analysis models to target platform architectures, such as J2EE and .NET, and eventually, to code. Rather than focusing on the problem domain, they have to deal with the complex details of the target platforms. The analysis and design models - being just additional documentation artifacts - are often not properly maintained in the face of approaching deadlines. This makes the applications hard to evolve later. Retargeting an application to a new platform is almost as difficult as writing it from scratch. Model-Driven Architecture (MDA) is a framework for model-based development being standardized by the Object Management Group (OMG) that addresses these problems. In MDA, models are the primary source of an application. All other artifacts, such as code, tests, and documentation, are (mostly) automatically derived from models.
In this tutorial, we will take a critical look at the promises made by MDA and clearly distinguish what is possible today from the visions of tomorrow. After explaining basic MDA concepts, such as metamodeling and model transformations, we'll discuss tool requirements and review some existing MDA tools. We'll round up the tutorial with a demonstration of generating a complete J2EE and .NET application from the same high-level UML model.
Attendee background
Prerequisites: Attendees should have basic knowledge of UML.
Format
Lectures and demonstrations
Presenters
Dr. Krzysztof Czarnecki is an Assistant Professor at the University of Waterloo, Canada. Before coming to Waterloo, he spent 8 years at DaimlerChrysler Research working on the practical applications of generative programming (GP). He is co-author of the book "Generative Programming" (Addison-Wesley, 2000), which is regarded as seminal work of the area and is used as a graduate text at universities around the world. He is General Chair of the 2003 International Conference on Generative Programming and Component Engineering (GPCE). His current research focuses on realizing the synergies between GP and model-driven architectures.
Petter Graff is Vice President of InferData Corporation. He has developed object-oriented systems for more than 20 years. At InferData, his focus is in object-oriented component development, software architectures and advanced implementation techniques for enterprise applications. He created one of the first model transformation tools (MCC) and is currently responsible for the development of InferData's next generation agent-based model transformation tool. Petter is also coauthoring an upcoming book on Model Driven Development (estimated to be published fall 2003).
57 Test-Driven Development Workout: Building Java MuscleThursday, 30 October – 8:30-12:00 Morning |
Programming skills are back in style!
Test-driven development is based on a cycle of testing, coding, and refactoring. The meat of this session is a real-time workout where you explore and exercise your skills in techniques that build rippling muscles for Java developers.
Whether you want to become a bodybuilding champion or a top-drawer developer, choice of regimen is critical. For developers, writing the tests first changes the way you design, improves the quality of your code, and guarantees your code is testable.
Like a bodybuilder's high-protein diet, refactoring shows you how to take code that merely works, and turn it into lean, easy-to-understand code that you'll be proud of.
This tutorial cranks up the workout intensity with pair programming (a form of spotting), a contest, and prizes, all designed to maximize your sweat equity in building your Java muscle.
This class is for Java programmers only. Bring a laptop if you can, with a Java environment and JUnit installed and working. If you don't have a laptop, that's cool--we'll pair you with someone who does. Either way, please contact William.Wake@acm.org and tell him whether you're pumping your own iron or need to share.
Attendee background
Prerequisites: Attendees must be able to program in Java.
Format
Lecture and hands-on exercises with partners
Presenters
William Wake is an independent consultant interested in agile methods, patterns, and human-computer interaction. He is the author of "Extreme Programming Explored" and the "Refactoring Workbook."
Steve Metsker is a researcher and author who explores and writes about ways to expand the abilities of developers. Steve is the author of "Building Parsers in Java," "Design Patterns Java Workbook," and the forthcoming "Design Patterns C# Workbook."
58 Object-Oriented Modelling with UMLThursday, 30 October – 8:30-12:00 Morning |
This tutorial introduces the UML (Unified Modeling Language) through the concepts of modelling. Having explained why it is useful to think about modelling before coding, the basic modelling concepts and notations of the UML are introduced, with focus on class diagrams and relationship modelling. More detailed topics are also considered: responsibilities, stereotypes, interfaces, roles, types, components and packages, dependencies, interaction diagrams, statechart diagrams and use cases.
Attendee background
Prerequisites: Knowledge of OO concepts will be beneficial; no knowledge of methodologies or modelling is required.
Format
Lecture
Presenters
Brian Henderson-Sellers is Director of the Centre for Object Technology Applications and Research (COTAR) and Professor of Information Systems at University of Technology, Sydney (UTS). He is author of eleven books on object technology and is well-known for his work in OO methodologies (MOSES, COMMA, OPEN, OOSPICE) and in OO metrics. Professor Henderson-Sellers has contributed as a member of the Review Panel for the OMG's Software Process Engineering Model (SPEM) and the UML 2.0 review team. In July 2001, Professor Henderson-Sellers was awarded a Doctor of Science (DSc) from the University of London for his research contributions in object-oriented methodologies.
Magdy Serour is a Research Fellow at the Centre for Object Technology Applications and Research at University of Technology, Sydney (UTS). He is the co-founder of SB the Software Group Pty Ltd (1982) and has had 25 years of experience in Information Technology, being significantly involved in Object technology adoption, process engineering, requirement engineering, modelling, implementation and IT consulting. At the moment, he is working in software process improvement and capability determination for object oriented/ component based software development (OOSPICE).
Cesar Gonzalez-Perez is a post-doctoral research fellow at the Faculty of Information Technology at UTS, where he works on object-oriented methodologies. He is the founder and former technical director of Neco, a company based in Spain specialising in software development support services, which include the deployment and use of OPEN/Metis at small- and mid-sized organizations. He has also worked for the University of Santiago de Compostela in Spain as a researcher in computing and archaeology, and was awarded a PhD in this topic in 2000.
OOPSLA Keynote - The Internet Paradigm ShiftThursday, 30 October – 8:30-10:00 |
 |
The computer industry has gone through a sea change in the past few years. The killer applications of the web era turned out not to be PC-based software packages like the web browser, but web hosted applications like google, mapquest and amazon.com. These applications are built on top of Linux and Apache, yet they are themselves fiercely proprietary. But what would most developers do with their source code? These massive systems are valuable for their data as much as for their programs. And by opening up XML web services APIs to that data, the most innovative of these sites are creating new opportunities for hackers to re-use that data and "scratch their own itch." What's more, as constantly updated services, these applications operate on very different timelines and processes than conventional software development. One of the greatest challenges for developers in the next few years is to understand and adapt to the paradigm shift implicit in network computing, and to shed the legacy thinking of the desktop era.
Speaker
Tim O'Reilly is founder and president of O'Reilly & Associates, thought by many to be the best computer book publisher in the world. In addition to publishing pioneering books like Ed Krol's The Whole Internet User's Guide & Catalog (selected by the New York Public Library as one of the most significant books of the twentieth century), O'Reilly has also been a pioneer in the popularization of the Internet. O'Reilly's Global Network Navigator site (GNN, which was sold to America Online in September 1995) was the first Web portal and the first true commercial site on the World Wide Web.
Tim has been an activist for internet standards and for Open Source software. He has led successful public relations campaigns on behalf of key internet technologies, helping to block Microsoft's 1996 limits on TCP/IP in NT Workstation, organizing the "summit" of key free software leaders where the term "Open Source" was first widely agreed upon, and, most recently, organizing a series of protests against frivolous software patents. Tim received Infoworld's Industry Achievement Award in 1998 for his advocacy on behalf of the Open Source community.
Garbage Collection 1Thursday, 30 October – 8:30-10:00 |
8:30 - 9:00 |
Mostly Concurrent Garbage Collection RevisitedKatherine Barabash,
IBM Haifa Research Laboratory,
kathy@il.ibm.com
The mostly concurrent garbage collection was presented in the seminal paper of Boehm et al. With the deployment of Java as a portable, secure and concurrent programming language, the mostly concurrent garbage collector turned out to be an excellent solution for Java's garbage collection task. The use of this collector is reported for several modern production Java Virtual Machines, and it has been investigated further in academia. In this paper, we present a modification of the mostly concurrent collector which improves the throughput, the memory footprint, and the cache behavior of the collector without foiling the other good qualities (such as short pauses and high scalability). We implemented our solution on the IBM production JVM and obtained a performance improvement of up to 22.8%, a reduction in the heap consumption by up to 13.6%, and no substantial change in the (short) pause times. The modified algorithm has subsequently been incorporated into the IBM production JVM. |
|---|---|
9:00 - 9:30 |
An On-the-Fly Mark and Sweep Garbage Collector Based on Sliding ViewsHezi Azatchi,
Technion - Israel Institute of Technology,
hezia@cs.technion.ac.il
With concurrent and garbage collected languages like Java and C# becoming popular, the need for a suitable non-intrusive, efficient, and concurrent multiprocessor garbage collector has become acute. We propose a novel mark and sweep on-the-fly algorithm based on the sliding views mechanism of Levanoni and Petrank. We have implemented our collector on the Jikes Java Virtual Machine running on a Netfinity multiprocessor and compared it to the concurrent algorithm and to the stop-the-world collector supplied with Jikes JVM. The maximum pause time that we measured with our benchmarks over all runs was 2ms. In all runs, the pause times were smaller than those of the stop-the-world collector by two orders of magnitude and they were also always shorter than the pauses of the Jikes concurrent collector. Throughput measurements of the new garbage collector show that it outperforms the Jikes concurrent collector by up to 60%. As expected, the stop-the-world does better than the on-the-fly collectors with results showing about 10% difference. On top of being an effective mark and sweep on-the-fly collector standing on its own, our collector may also be used as a backup collector (collecting cyclic data structures) for the Levanoni-Petrank reference counting collector. These two algorithms perfectly fit sharing the same allocator, a similar data structure, and a similar JVM interface. |
9:30 - 10:00 |
Heap Compression for Memory-Constrained Java EnvironmentGuangyu Chen,
The Pennsylvania State University,
gchen@cse.psu.edu
Java is becoming the main software platform for consumer and embedded devices such as mobile phones, PDAs, TV set-top boxes, and in-vehicle systems. Since many of these systems are memory constrained, it is extremely important to keep the memory footprint of Java applications under control. The goal of this work is to enable the execution of Java applications using a smaller heap footprint than that possible using current embedded JVMs. We propose a set of memory management strategies to reduce heap footprint of embedded Java applications that execute under severe memory constraints. Our first contribution is a new garbage collector, referred to as the Mark-Compact-Compress (MCC) collector, that allows an application to run with a heap smaller than its footprint. An important characteristic of this collector is that it compresses objects when heap compaction is not sufficient for creating space for the current allocation request. In addition to employing compression, we also consider a heap management strategy and associated garbage collector, called MCL (Mark-Compact-Lazy Allocate), based on lazy allocation of object portions. This new collector operates like the conventional Mark-Compact (MC) collector, but takes advantage of the observation that many Java applications create large objects, of which only a small portion is actually used. In addition, we also combine MCC and MCL, and present MCCL (Mark-Compact-Compress-Lazy Allocate), which outperforms both MCC and MCL. We have implemented these collectors using KVM, and performed extensive experiments using a set of ten embedded Java applications. We have found our new garbage collection strategies to be useful in two main aspects. First, they reduce the minimum heap size necessary to execute an application without out-of-memory exception. Second, our strategies reduce the heap occupancy. That is, at a given time, they reduce the heap memory requirement of the application being executed. We have also conducted experiments with a more aggressive object compression strategy and discussed its main advantages. |
Agile Management—An Oxymoron?Thursday, 30 October – 8:30-10:00 |
"Self-directed team" is one of the mantras of Agile Methodologies. Self-direction means that the team's manager is relegated to a facilitator role with little or no influence over day-to-day activities. For example, Kent Beck has written that the manager of an XP project can do four things: ask for estimates on cost and results, move people around among projects, ask for status reports, and cancel the project. Agile literature in general says that managers shouldn't be directly involved in analysis, design, coding, testing or integration. They may (but only occasionally!) facilitate the process between the customer and the developers; and it would be nice if they provided food and toys to keep the team happy. It appears, then, that the agile manger is expected to hover on the fringes of a project asking a few questions and throwing in goodies—but with ultimate power (cancellation) in her hip pocket. This scenario makes one wonder. Do managers really matter to the success of an agile project? Are they superfluous? What happens when managers step over the prescribed line—does it mean that the end of Agile Methodology as we know it and as handed down by the Agile Manifesto? The panel will explore this ticklish terrain by answering the following questions: Why Agile Methods and managers don't mix. Or do they? What can/should managers do in an agile environment? Under what conditions are managers an absolute requirement in an agile environment? (e.g. Government applications?) Do good management techniques apply to both Agile and non-Agile environments? Is management a dead-end profession in an Agile world?
Student Research Award PresentationThursday, 30 October – 8:30-8:35 |
Garbage Collection 2Thursday, 30 October – 10:30-12:00 |
10:30 - 11:00 |
MarkCopy: Fast Copying GC with Less Space OverheadNarendran Sachindran,
University of Massachusetts Amherst,
naren@cs.umass.edu
Copying garbage collectors have several advantages over non-copying collectors, including cheap allocation and prevention of fragmentation. However, in order to provide completeness (the guarantee to reclaim each garbage object eventually), standard copying collectors require space equal to twice the size of the maximum live data for a program. We present a mark-copy collection algorithm that extends generational copying collection and significantly reduces the heap space required to run a program. The new collector runs in space that is nearly a factor of two smaller than that required by standard copying garbage collectors, increasing the range of applications that can use copying garbage collection. We show that when the collector is given the same amount of space as a generational copying collector, it improves program execution time of Java benchmarks by 20-85% in tight heaps and by 5-10% in moderate size heaps. We also compare the performance of the mark-copy collector with that of a mark-sweep collector. We find that, for several benchmarks, the mark-copy collector can run in heaps comparable in size to the minimum heap space required by the mark-sweep collector. We also find that for some benchmarks the mark-copy collector is significantly faster than a mark-sweep collector in tight heaps. |
|---|---|
11:00 - 11:30 |
Ulterior Reference Counting: Fast Garbage Collection without a Long WaitSteve Blackburn,
Australian National University,
Steve.Blackburn@anu.edu.au
General purpose garbage collectors have yet to combine short pause times with fast throughput. For example, non-concurrent generational collectors can achieve high throughput and have modest average pause times, but occasionally collect the whole heap and consequently incur long pauses. On the other extreme, concurrent collectors, including reference counters, attain short pause times with significant performance penalties. This paper introduces GenRC, which combines copying generational collection and reference counting the older generation to achieve both goals in a uniprocessor setting. Key to our algorithm is a generalization of deferred reference counting which allows GenRC to safely ignore mutations to nursery objects. GenRC thus restricts copying and reference counting to the object demographics for which they perform well. The contiguous allocation of a copying collector is extremely fast, and collection time is proportional to the live objects whose survival rates are usually low in a fixed size nursery. Reference counting time is proportional to object mutations and the number of dead objects, both of which are typically low for older objects. We further restrict the time spent reference counting with collection triggers and buffering. We compare GenRC using a fixed nursery (FG-RC) with pure reference counting (RC), high performance copying and mark-sweep fixed nursery generational (FG-MS), and pure mark-sweep collectors (MS). We show that FG-RC is competitive with FG-MS on throughput, and attains much lower average and maximum pause times. |
11:30 - 12:00 |
Connectivity-Based Garbage CollectionMartin Hirzel,
University of Colorado at Boulder,
hirzel@cs.colorado.edu
We introduce a new family of connectivity-based garbage collectors (CBGC) that are based on potential object-connectivity properties. The key feature of these collectors is that the placement of objects into partitions is determined by performing one of several forms of connectivity analyses on the program. This enables partial garbage collections, as in generational collectors, but without the need for any write barrier. The contributions of this paper are 1) a novel family of garbage collection algorithms based on object connectivity; 2) a detailed description of an instance of this family; and 3) an empirical evaluation of CBGC using simulations. Using simulations allows us to explore a broad range of possibilities for CBGC, ranging from simplistic ones that determine connectivity based on type information to oracular ones that use run-time information to determine connectivity. Our experiments with the oracular CBGC configurations give us an indication of the potential for CBGC and also identify weaknesses in the realistic configurations. We found that even the simplistic implementations beat state-of-the-art generational collectors with respect to some metrics (e.g., pause times and memory footprint). |
Object-Oriented Success Stories: "Learning from our Failures"Thursday, 30 October – 10:30-12:00 |
Beneath the buzz around methodologies, languages and technologies, the last eighteen years at OOPSLA have seen countless object-oriented success stories, large and small. This fishbowl will provide OOPSLA attendees to bear witness to these victories, and tell these tales at last. Similarly we propose a follow-up fishbowl that discusses our failures. Just as much (if not more) can be learned from failures as can from successes.
Panel: Reuse Repositories and Reuse—The RealitiesThursday, 30 October – 10:30-12:00 |
This session starts with a photo-essay on components, reuse, value, and beauty, and concludes with a panel on libraries, repositories, and reuse.
Without a Name: A Reusable Component RepositoryRobert Biddle,
Victoria University of Wellington, New Zealand,
robert@mcs.vuw.ac.nz
The Story - this essay concerns components, reuse, value, and beauty. All photographs were taken at No Name Building Recyclers, Wellington, New Zealand, with the kind permission of the owners. |
Panel: Reuse Repositories and Reuse—The RealitiesDave Thomas,
Bedarra Research Labs & Carleton University,
dave@bedarra.com
This panel (part of the 2003 Onward! program) will discuss repositories, and reuse. While there is so much hype and noise about components and model repositories, metadata and reuse there is still very little understood about how hard it is to design for reuse and to encourage systematic reuse both in terms of culture, design, and supporting tools and technology. Like standards we have a plethora of component models to choose from and yet the long predicted component market place has yet to occur or has it already happened? Our educational colleagues outside of the our community are blindly following our rhetoric to build eLearning repositories so Learning Objects can be snapped together just like the OO folks do it! Similarly object zealots are arguing for OO XML, OO CSS to facilitate reuse OO style. Our panelists have participated in both the euphoric vision as well as the pragmatic realities of repositories reuse in practice. The panel has been asked to discuss their future vision for reuse and repositories and in particular what key social, business and technical enablers will facilitate significant reuse or render the matter irrelevant. |
AnalysisThursday, 30 October – 10:30-11:30 |
10:30 - 11:00 |
Declaring and Checking Non-null Types in an Object-Oriented LanguageManuel Fähndrich,
Microsoft Research,
maf@microsoft.com
Distinguishing non-null references from possibly null references at the type level can detect null-related errors in object-oriented programs at compile-time. This paper gives a proposal for retrofitting a language such as C# or Java with non-null types. It addresses the central complications that arise in constructors, where declared non-null fields may not yet have been initialized, but the partially constructed object is already accessible. The paper reports experience with an implementation for annotating and checking null-related properties in C# programs. |
|---|---|
11:00 - 11:30 |
Object Equality ProfilingDarko Marinov,
MIT Laboratory for Computer Science,
marinov@lcs.mit.edu
We present Object Equality Profiling (OEP), a new technique for helping programmers discover optimization opportunities in programs. OEP discovers opportunities for replacing a set of equivalent object instances with a single representative object. Such a set represents an opportunity for automatically or manually applying optimizations such as hash consing, heap compression, lazy allocation, object caching, invariant hoisting, and more. To evaluate OEP, we implemented a tool to help programmers reduce the memory usage of Java programs. Our tool performs a dynamic analysis that records all the objects created during a particular program run. The tool partitions the objects into equivalence classes, and uses collected timing information to determine when elements of an equivalence class could have been safely collapsed into a single representative object without affecting the behavior of that program run. We report the results of applying this tool to benchmarks, including two widely used Web application servers. Many benchmarks exhibit significant amounts of object equivalence, and in most benchmarks our profiler identifies optimization opportunities clustered around a small number of allocation sites. We present a case study of using our profiler to find simple manual optimizations that reduce the average space used by live objects in two SpecJVM benchmarks by 47% and 38% respectively. |
Eclipse and The Dark Side of the MoonThursday, 30 October – 13:30-15:00 |
 |
Eclipse (www.eclipse.org) is an open source universal tool platform for anything and nothing in particular. This talk looks at Eclipse inside the corona.
Speaker
Erich Gamma leads the Eclipse Java Development tools project and is a member of the Eclipse project management committee. He is also a member of the Gang of Four, which is known for their book: Design Patterns - Elements of Reusable Object-Oriented Software. Erich has paired with Kent Beck to develop JUnit, a popular testing tool for Java. Before joining OTI he was working at Taligent on a never shipped C++ development environment. Erich started with object-oriented programming over 20 years ago as a the co-author of ET++ one of the first large scale C++ application frameworks.
Erich Gamma is the site lead of the IBM OTI Lab in Zurich, Switzerland. He has a doctorate in computer science from the University of Zurich. Erich was a Swiss ski instructor but never a fan of Pink Floyd.
Transactions and PersistenceThursday, 30 October – 13:30-15:00 |
13:30 - 14:00 |
Saving the World from Bad Beans: Deployment-Time Confinement CheckingDave Clarke,
Utrecht University,
dave@cs.uu.nl
The Enterprise JavaBeans (EJB) framework requires developers to preserve architectural integrity constraints when writing EJB components. Breaking these constraints allows components to violate the transaction protocol, bypass security mechanisms, disable object persistence, and be susceptible to malicious attacks from other EJBs. We present an object confinement discipline that allows static verification of component integrity as they are deployed into an EJB server. The confinement rules are simple for developers to understand, require no annotation to the code of EJB components, and enforcement of these rules can be incorporated efficiently into existing EJB servers. |
|---|---|
14:00 - 14:30 |
Language Support for Lightweight TransactionsTimothy Harris,
University of Cambridge Computer Laboratory,
tim.harris@cl.cam.ac.uk
Concurrent programming is notoriously difficult. Current abstractions are intricate to use and make it hard to design computer systems that are reliable and scalable. We argue in favour of a practical declarative style of concurrency control in which programmers directly indicate the safety properties that they require. In essence, the programmer demarks sections of code which execute within lightweight software-based transactions which commit atomically and exactly once. These transactions can update shared data, instantiate objects, invoke library features and so on. They can also block, waiting for arbitrary boolean conditions to become true. These features support general-purpose shared data structures such as hashtables, queues and buffers. In general, no performance penalty is incurred for memory accesses outside transactions. Furthermore, transactions which do not access the same shared memory locations can commit concurrently. We present a detailed design of this proposal along with an implementation and evaluation. We argue that the resulting system (i) is easier for mainstream programmers to use, (ii) prevents lock-based priority-inversion and deadlock problems and (iii) offers compelling performance. |
14:30 - 15:00 |
Lazy Modular Upgrades in Persistent Object StoresChandrasekhar Boyapati,
MIT Laboratory for Computer Science,
chandra@lcs.mit.edu
Persistent object stores require a way to automatically upgrade persistent objects. Automatic upgrades are a challenge for such systems. Upgrades must be performed in a way that is efficient both in space and time, and that does not stop application access to the store. In addition, however, the approach must be modular: it must allow programmers to reason locally about the correctness of their upgrades similar to the way they would reason about regular code. This paper provides solutions to both problems. The paper first defines upgrade modularity conditions that any upgrade system should satisfy to support local reasoning about upgrades. The paper then describes a new approach for executing upgrades efficiently while satisfying the upgrade modularity conditions. The approach exploits object encapsulation properties in a novel way. The paper also describes a prototype implementation and shows that our upgrade system imposes only a small overhead on application performance. |
What's so eXtreme About Doing Things Right?Thursday, 30 October – 13:30-15:00 |
Agile Methods are advocated as a way of producing better software. Advocates of agile methods suggest that practices such as keeping in close communication with your customers, frequent integration, and frequent assessment of project status will enable us to produce software that has value for the customer—quality software. It's hard to argue with that. But why is this any different than simply "good" software development practice? Why does saying "Scrum" "Agile" or "XP" grab peoples' attention? Why does it take a name for useful practices to be accepted? This panel will help us understand the role of hype in getting useful practices accepted or rejected. We will explore why it is that these good ideas have not been more widely used. Some of the questions that the panel and the audience will explore are: Why do we ignore proven practices until we see them packaged as a "method?" Can we do something different in the workplace or in school to teach these practices? Or is it the case that these practices are not universally good? This panel talks about agility in a different context than what is typical: we won't just discuss what agile practices are. We will explore why they are not more widely adopted, especially when not packaged as part of a "named" method like XP, and we will discuss why projects suffer even when the methods that can help them are well known. This panel will provide an entertaining and thought provoking forum for discussing an issue that is ever present in the world of technology: the role of hype. We concentrate on agile practices, moving beyond simply enumerating them, to discussing why they are not more widely adopted.
Application Servers: One Size Fits All ... Not?Thursday, 30 October – 13:30-15:00 |
In the beginning there was machine language, followed by assembly language, formula translation, and eventually procedural programming, to organize the chaos. And then objects were introduced, to hide information. Soon Client/Server and multi-tier applications were conceived to separate data concerns from business logic concerns and user interface concerns. Later, these objects were distributed geographically to optimize hardware resources. And now, we have application servers, to simplify scaling up a system for large volumes, improved response times, impeccable reliability, and high availability. Application servers house the business logic, operating on data from a different server, and responding to requests from any source. But these Application Servers come in all shapes, flavors, and sizes. What is a developer to do? This panel will explore issues comparing application server technologies and questions about their appropriate use in different contexts.
Ice Cream Social (OOPSLA 2004 Kick-off)Thursday, 30 October – 15:00-17:00 |
The Ice Cream Social serves as both the farewell event of OOPSLA 2003 and the kick-off event of OOPSLA 2004. It is also the setting for the DesignFest Wrap-up. Throughout the week, teams of software designers have taken part in the DesignFest sessions. In addition, a small number of student teams (known as CodeFest) have implemented some of these designs. The Ice Cream Social is a chance for OOPSLA participants, whether or not they participated in DesignFest, to see the designs produced during the earlier sessions, as well as to view demos of the final software. Designers will be available to discuss their experiences (both good and bad) of working in their design team, and the CodeFest teams will describe the problems they encountered while implementing the designs.