Thursday, 30 October

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.

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.

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.

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

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.)

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'").

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.

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.

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.

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.

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.

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.

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.

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.

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.

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).

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."

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 Shift Thursday, 30 October – 8:30-10:00 Tim O'Reilly, O'Reilly and Associates, tim@oreilly.com

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.