Application Servers promise to allow organization to achieve new levels of scalability. But demonstrating scalability is a challenge. Applied Reasoning's product development team created a benchmarking application to demonstrate how well an application server meets the demands in an "extreme environment". The test lab reproduces an environment with high transaction rates and high user activities, pushing past the limits of a typical system.

Combining Classic Blend, VisualWorks Smalltalk and Oracle, the application loads 50+ concurrent users on a single standard processor (200 megahertz Pentium Pro) and performs various transactions on an Oracle database. Conducted over the Internet to a remote server located in Cary, North Carolina, client machines at the test lab in Cary and on-site at the product demonstration access the application performing update, remove and queries to the database. Client machines during the product demonstration will monitor the results of the test and interact with applications being serviced by that server.

The monitoring tools track the network message rate and database transaction rate as well as control the time between transactions. These rates are displayed in various forms (averages, maximum, current values, charts, graphs, etc.). The demonstration will indicate the average message rate per second (>150 msg/sec), average total transaction rate per second (nearly 100/sec), average application server CPU load, average database server CPU load and other measurements.

We will demonstrate applications of hierarchy display tools of the Giza framework, focusing on representation of class inheritance and aggregation hierarchies, more specifically the Java class hierarchy.

Our representation tools (Cheops and the Millipede) use an innovative representation technique, visual elision, to display large hierarchies with comparatively few visual elements. This technique renders each logical element as a meaningful combination of states of visual nodes, preserving neighborhood relationships and allowing fast navigation. Furthermore, the Millipede can represent non-hierarchical links in basically hierarchical structures, as can be found in cases of multiple inheritance.  First, we will introduce the representation tools themselves, starting with the principles of the elision technique and how it allows representation of large hierarchies; then we will demonstrate various navigation techniques and how they interact. Second, we will show how these tools are adapted to analysis of complex structural data: representation of non-hierarchical links, visual filtering of information, spatial redistribution of structural elements according to various criteria, etc.  Third, we will show how multiple instances of our tool can attach to various aspects of our data model. In particular, we will show a representation of the aggregation hierarchy derived from a class.

The Giza framework relies on the RoleAdapter Design Pattern, presented separately as a Tech Note, to allow generic views to attach to specific aspects of an arbitrary model. The RoleAdapter will be presented briefly, with an emphasis of the steps involved in adapting some model to the Giza-based visualization tools. Some code examples will be provided. If time allows, we will show how multiple coupled views on different aspects of  a data model can interact to give a richer and clearer representation than either single or mixed views.

• Reduction of bottlenecks resulting from updates to shared classes
• Support for multiple views
• Unintrusive application extension, even when the extension is unplanned
• Flexible customization by inclusion or exclusion of application "features"
• Reduction of the mismatch between design and implementation architectures
• More elegant coding of several design patterns

There are several elements to Siren:

• the Smoke music representation language (music magnitudes, events, event lists, generators, functions,  and sounds);
• voices, schedulers and I/O drivers (real-time and file-based voices for sound and MIDI I/O);
• user interface components for musical applications (UI framework, widgets, and tools); and
• several built-in applications (editors and browsers for Siren objects).

The "kernel" of Siren is the set of classes for music magnitudes, functions and sounds, events, event lists and event structures known as the Smallmusic Object Kernel (Smoke) music representation. Smoke is described in terms of two related description languages (music input languages), a compact binary interchange format, and concrete data structures. The high-level packages of Siren--voices, sound/DSP, compositional structures, and the user interface framework--interoperate using Smoke event lists.

Real-time music I/O in Siren is managed by Squeak primitive interfaces to sound and MIDI OS-level drivers. The glue code for these primitives is written in Smalltalk and translated to C for linking with the Squeak virtual machine (itself written in Smalltalk and translated). Several sets of primitives exist for Squeak on various platforms, including support for sound synthesis, digital audio signal processing, MIDI event-oriented and continuous controller I/O, and VM-level scheduling.

The Smalltalk-80 Model-View-Controller (MVC) user interface paradigm (Krasner and Pope 1988), is well-known and widely imitated. The traditional three-part MVC architecture involves a model object representing the state and behavior of the domain model--in our case, this would be an event list or signal. The view object presents the state of the model on the display, and the controller object sends messages to the model and/or the view in response to user input. "Navigator MVC" (Pope, Harter, and Pier, 1989) is a factoring of the controller/editor and view for higher levels of reuse. The fundamental feature of this architecture is that all applications are built as display list editors (i.e., the generic tool is "smart MacDraw"), with special layout manager objects for translating the model structure into a graphical display list pre-presentation and for translating structure interaction into model manipulation. The Siren implementation of Navigator MVC is integrated with the Morphic (Maloney and Smith, 1995) graphics framework.

Structure Builder (SB) from Tendril Software is an innovative tool for Java software development. In UML, program behaviour is expressed as object interaction diagrams. A key innovation of SB is that it allows the developer to generate Java code from these object interactions. This allows for quick and accurate code generation for significant parts of the program and it reduces the code for manipulation and navigation of data structures. A UML class diagram serves as the structural architecture which is used to derive the methods. A program is separated into object navigation and additional processing.

A collaboration is expressed in terms of a set of traversals which collect the participant objects of the collaboration. For example, if you have an object o and you need a subobject three levels down, you click the UML class diagram to define the path o.a.b.c and call get. This will make the object referred to by the path available. Any number of participant objects may be collected this way. Instead of calling "get" we could also call "execute" to call a designated method and return its result. A benefit of this approach is that the detailed Java code for carrying objects around is automatically generated by SB. Automatic object transportation is a general feature of SB.

Structure Builder is introducing two concepts: an object tracker model and a code fragment model. The object tracker keeps track of the objects which are available at a given point in a collaboration. A significant part of the programming task is ensuring that objects are transported to where they are needed in a program. Object tracker automates this task.

The code fragment model incorporates the following features: A code fragment takes several objects as input and produces several objects as output. A code fragment consists of a path, followed by an action name and associated properties. The kind of actions which can be called depends on the type of the object. All objects support the actions, execute, get and newMethod. Additional actions are defined for other types. For instance, the popular Java collection type, Vector, has the following additional actions: add, remove, find and iterate.

A collaboration is a sequence of code fragments. Each code fragment makes available output objects which may be used by code fragments later in the sequence. Each path in a code fragment may also contain extra code to be executed when the path is traversed.

The SB approach is general and powerful and facilitates the design and coding of Java programs. The strong reverse engineering capabilities of SB allow software developers to take their existing Java programs and continue development in a simplified way in SB style.

The demonstration will include:

The Aviation System Analysis Capability (ASAC) is a diverse collection of models, databases, analysts, and individuals from the public and private sectors brought together to work on the issues of common interest to organizations within the aviation community. With the ASAC Executive Assistant, researchers at NASA and elsewhere can quickly evaluate the economic potential of alternative technologies and systems. By linking the many distributed models and data that comprise the ASAC system, the Executive Assistant provides an intelligent interface with which the user can perform detailed analyses.

The Analysis and Visualization System (AVS) is a Web-based information system for viewing, analyzing, and modifying information related to the life-cycle management of waste and contaminated media in the Department of Energy (DOE) complex. The information in AVS is accessible to registered users through a browser such as Netscape or Internet Explorer.

The Refactoring Browser is a freely-available reimplementation of the standard Smalltalk system browser that adds several refactorings to the standard operations provided by the browser. It is distributed in the goodies directory of VW3.0. The refactorings that are implemented are fast and safe and have been used successfully on several commercial software projects.

The refactorings range from mundane operations such as adding classes and instance variables, to the complex such as moving a method from one class to another through either an argument or an instance variable. In addition to the refactorings, the Refactoring Browser also provides an auxilliary tool that can detect hard-to-find bugs and common style errors in Smalltalk programs. For instance, it can detect situations when the standard do: iterator was used instead of a more specific one such as select: or collect:.

We will demonstrate the various refactoring techniques by refactoring the running Smalltalk image itself. We will rename Object and the new method to demonstrate the safety of the refactorings.

Software evolution is crucial to keep up with the evolution of the society we live in. However, bad software comprehension, poor effort estimation and poor insight into the effects of changes make it hard to evolve software correctly. The development process itself may even give rise to software evolution problems such as version proliferation, architectural drift, and overfeaturing. Preserving software from aging is not easy. The fundamental problem is a bad comprehension of the software architecture or the software design architecture - the organisation of the source code as composition of components and the interaction between them. Software documentation as we know it today does not appear to help. In the worst case, no documentation whatsoever exists. In many other cases, if documentation is done at all, it is often done after the fact, that is, after the software has reached a stable state. That explains the popularity of class report generators, which produce pretty-printed class definitions, including all methods and source comments collected from the implementation. One may wonder about the usefulness of such class reports, since they seldom contain more than can be found with the standard development tools.

This demonstration shows the use of the GoWeb system, an infrastructure for enabling computer resources for use within World Wide Web with a standard Web browser as a front-end. It is a distributed  (client/server) interface software placed between the existing computer resources and Web browsers. The GoWeb system has been designed and developed as a robust cross-platform middleware. Machine independent code, produced by Java interpreter, ensures the use of the system at any computer with JVM (Java Virtual Machine). It is a dynamic environment, configured on run-time, that scales up without a need for re-programming or restart.

The GoWeb system will be demonstrated by several examples:

The Object-Process Methodology (OPM) is a system development approach that integrates structure and behavior of the system within a single unifying model. The conventional wisdom has been that there is an inherent dichotomy between object- and process-oriented approaches, and that it is not possible to combine these two essential aspects of any system into one coherent integral frame of reference. This misconception has accompanied systems analysis to the extent that even the current proposal of the UML (Booch and Rumbaugh, 1995; Booch and Rumbaugh, 1996) maintains the separation between structure and behavior.  UML spreads analysis activities across no less than seven types of diagrams: class diagram, use case diagram, message trace diagram, object message diagram, state diagram, module diagram, and platform diagram.

The Goal of OPCAT is to support system development through OPM and to supply a complete Integrated Software Engineering Environment (ISEE) for system developers. OPCAT (acronym for Object-Process CASE Tool) has been developed since 1994 as the Computer Aided Software Engineering (CASE) tool to support the Object-Process Methodology. As is the case with many successful industrial application, the development of OPCAT started in the academy--Technion, Israel Institute of Technology--by a team of students as a fourth year undergraduate project in information systems engineering. It was carried out under the guidance and supervision of the Dr. Dov Dori in his capacity as Senior Lecturer at the Technion. Since then OPCAT has evolved from a modest program to a semi-commercial product with version control and configuration management. The current version of OPCAT is Version 1.6.  OPCAT in its current version is designed to serve as a tool for drawing OPD sets. This is the routine activity at the basis of the Object-Process Methodology. The program is written for the Microsoft Windows 95® operating system in Visual C++ and supports multilingual operation, including Hebrew, flexible floating icon boxes and all the other features of a friendly graphic user interface.

The demonstration will focus on a case study which demonstrates the OPM features and the OPCAT current functionality. In particular we will:

An on-going issue in higher education is how to measure the value of the education received by a student.  This is called longitudinal assessment. For the institution, longitudinal assessment has two major purposes:  to assist in the process of accreditation; and to collect information which can be used in curriculum enhancement.

The process currently in place at Cal Poly is a paper process: paper questionnaires are mailed out to alumni; the responses are manually entered into different types of files; and finally the files are browsed to collect and analyze data. Our project automates this process, enabling response collection via the Web, and will also add new high-tech functionalities. The users of this project are intelligent but naïve users; they want a useful but not demanding tool. We chose to use an object-oriented approach, and to implement the project using an ODBMS (Object-oriented Database Management System). The users supplied the host machine, a Windows NT PentiumII dual-processor machine with 6GB of disk space and 128 MB RAM. The NT Server runs Microsoft IIS (web server software) and Versant's Object-Oriented Database Management System as the back-end data storage and management unit. The interface is from the Cal Poly College of Engineering (CENG) Web site, which is accessible via any current secure web browser, such as Netscape 3.0 or higher, or Internet Explorer 3.0 or higher. A subset of the proposed tools have been implemented.