Due to exceptional circumstances Dan had to cancel his trip. We'll be looking forward to seeing him later.

SmallCharts is a tool written in VisualWorks Smalltalk to create charts for print publications. It captures the graphical design of standard charts and presents the non-technical and non-graphical editor with an easy interface to create professional charts ready for printing.

The development of smallCharts was driven by the need for more effective production of standard charts without sacrificing the quality of hand-made graphics. In the talk I will explain the consequences for the development process and how aspects of eXtreme programming were successfully applied. As a result of using test cases, relentless refactoring and packaging as well as early deliverables, the design of the software evolved over time. In the presentation I will show the current architecture, its history and major decisions.

Teaching computer architecture is an interesting but complex experience. Depending on the level of the students, courses should address the main topics from very different points of view, with very different requirements regarding tools for practical work. SmallTalk stands as a powerful environment to build all the required material for the computer architecture laboratory. The key to have a complete and configurable set of laboratory tools with a reduced buget is simulation, and SmallTalks is ideal for simulatig processors and other digital systems:

• it is really abstract, so data and instructions flowing into the corresponding paths can be processed as symbolic information or translated into their binary representations, according to the needs of the course.
• it is really flexible, so any functional unit, operator or instruction can be modified or added to the system without major modifications.
• it is really powerful as a high level language, so parsers of simple script dialects can be easily integrated into simulation frameworks to allow the modification of the control algorithms of any functional unit without modifying the simulator code.
• finally, the design of user interfaces is trivial, and helps to give a common feel for all the set of tools in the computer architecture lab.

The Computer Architecture group of the University Jaume I of Castell?SPAIN), working closely with the Laboratory of Architecture and Systems of the University of Bretagne Occidentale of Brest (FRANCE) has developped several simulators -using VisualWorks- to be used in Computer Architecture courses from first to fourth year of our degrees. Some of the curses are based in a common framework for digital simulation -and digital implementation on FPGAs also used in research work-, while others are completely different projects, that simulate all the computer system remaining at the symbolic level.

The objective of this practical experience proposal is to present to the SmallTalk community these works, and to discuss and go deeper into the exceptional characteristics of SmallTalk for computer architectrure simulation.

In this tutorial we will show how OmniBase is being used, its object model and meta-data features, we will take a look into OmniBase internals and also show how to extend it with new types of persistent objects. OmniBase, which is sometimes refered to as an object-database, is in reality ?just? a Smalltalk objects persistency system. OmniBase extends Smalltalk image with multi-user access and persistency capabilities. At the moment OmniBase is available for Dolphin Smalltalk, VisualAge Smalltalk, Cincom VisualWorks, plus independent ports for ST/X and Squeak. With OmniBase it is possible to store any Smalltalk object in the database with all its relationships with other persistent objects. OmniBase also provides some new objects which are optimized for persistency storage. Such objects include a virtual b-tree dictionaries which can be used for indexing large amounts of data. For concurrency control OmniBase employs multi-version concurrency control where readers never block writers and writers never block readers. Although this type of concurrency control provides high concurrency potential some of its implications have to be considered when one develops an application with OmniBase. Our goal is that after following the tutorial one should gather enough experience and information to be able to developed applications with the OmniBase object persistency system.

Last year at ESUG, we shared our experiences developing Web Services with the then nascent (beta) Web Services support in VW7. Looking back, it occurred to me that the work being done by our team of geographically dispersed developers was often done via remote pair programming. We often relied on remote collaboration tools to "share" an image between 2 or more developers depending on the problem at hand.

This year, we are continuing our development as a dispersed team. Kirk is in Denver. Stan, Saogat and others are in Minneapolis. As we continue our remote pair programming, we have chosen to concentrate not on the Web Services technologies in VisualWorks, but rather have chosen to focus on the processes and technologies that allow our team to have successful Virtual Pair Programming VPP experiences. Our main Smalltalk project is a large telecommunications OSS implemented in VisualWorks, with ENVY for software configuration management. As most developers know, the experience of developing against a remote ENVY repository can be painful at best

This report presents various techniques, tricks, and tips that can help developers achieve satisfactory VPP experiences despite the unique network performance challenges presented by ENVY when developing Smalltalk on WAN or distributed corporate LAN.

Additional topic: Emerging research topic: Virtual Pair Programming Recently, researchers have begun to do empirical studies on the effectiveness of VPP. In keeping with the research focus of ESUG this year, our presentation will review some of the recent empirical research on VPP. For example: http://www.cse.ucsc.edu/~brianh/papers/ICSE-Doctoral.pdf

SmallWiki is a new and fully object-oriented wiki implementation in Smalltalk. It is highly customizable and easily extensible with new components, looks, servers, storage, etc. A huge set of tests assures that it keeps stable while evolving.

The talk will let you have a look at SmallWiki from three perspectives: user, administrator and programmer. Most exciting features and important design decisions made during development will be presented. The talk will be closed with a demo, showing how to create a simple extension to SmallWiki.

Abstract to be communicated.

In 1972 when the research project was started which finally produced Smalltalk-80 the ultimate goal Alan Kay had in mind was the Dynabook, a personal dynamic book controlled (i.e. programmed) by the owner. Finally today there are hand-held computers on the market that are powerful enough to run Smalltalk. In 2003, mainly at CeBIT and after, Microsoft made the biggest marketing about mobility. Thus it is important to have Smalltalk on this platform and there it is.

The second hot Microsoft topic is .NET, the new way of Windows programming, and a unification of different programming languages. DotNETConnect is our way to integrate .NET into Smalltalk.

(Note: this talk replaces Blogs and RSS in VisualWorks, since James Robertson had to cancel).

AOStA is an "Adaptively Optimizing Smalltalk Architecture" that is being worked on by a community "founded" by Eliot Miranda. The purpose is to build a framework to optimize Smalltalk code adaptively at run-time, and an interface so that a VM that supports polymorphic inline caches and just-in-time compilation can determine the program hot-spots and ask the optimizer to work on them based on the type information that is contained in the inline caches. So far the work has been done by Eliot and me, but we hope to extend this to more people; equally, so far the work has been done on and for VisualWorks but we plan to extend this to GNU Smalltalk and hope that other implementations (such as Squeak and ST/X) will be involved.

I've been developing Smalltalk applications for many years. Recently, I was asked to explain my approach to testing and so I wrote a document explaining how I test as I develop.In doing this, I found 12 principles that I've used for a long time. Some are similar to those employed by Extreme Programming but others are fairly unique. My presentation will explain these principles in the context of an actual application development exercise.

Extreme Programming (XP) is a very successful, recent methodology for software development. XP developers heavily use tools supporting coding activities such as testing, refactoring, and continuous integration. X-Unit, the Refactoring Browser, and Cruise Control are, respectively, examples of tools automating these activities.

As regards project planning and tracking on the other hand, XP strives to be agile and lightweight, and does not encourage the production of documentation different from the code itself. However, many organizations are accustomed to using automated tools aiding project management and would welcome the availability of such tools. We present XPSwiki, an open source tool supporting the XP practices for requirement gathering and project management - user stories and the Planning Game. XPSwiki has been developed in Smalltalk using Squeak Swiki technology.

The main features supported by XPSwiki are:

• XPSwiki keeps track of multiple projects, each with its releases, iterations, user stories, acceptance tests and engineering tasks.
• It manages teams of developers, who sign stories and tasks, and who pair-program them with another team member.
• It is accessed through the Internet in an user friendly and agile way allowing it to be used even in distributed enviroments.
• XPSwiki allows project tracking and process statistics generation and, in the forthcoming version, it will be provided with process metrics collection capability.
• It allows the production of written documentation on project advancement, to comply with the ISO 9000 quality certification manual of a software firm.

In our bank we would like to use Smartcards to login on Windows and also into Gemstone (GS). Without modification of the Gemstone Database environment, we have implemented the following solution:

On the AIX-Server where the GS Database is running, there also runs a headless VW3.0-Application called "LogonServer" (LS). The LS accepts user requests for logging into GS by supplying an RSA-encrypted OneTimePassword (OTP) to the user, if there is the necessary credential information (X.509-certificate) found on the GS.

To be capable to accept user logon requests also in case the user has no smartcard, the LS can supply the OTP if the user has the corresponding credential information on the GS. In this case, the credentials just consist of well encrypted password information.

The talk discusses all these issues in some detail and shows code examples.

On the computer, we would like to work with objects that we know from our life. Currently we work with many different applications to acomplish our tasks and usually, our task requires the use of more than one application. Because applications do not usually cooperate, accomplishing some tasks is more difficult than it needs to be. In a single object environments, like Smalltalk, the problem of different selfish applications is eliminated by the nature of the environment. We have created a framework, called StepTalk, that produces an illusion of such an environment of cooperating objects. Our framework was inspired by the idea of Smalltalk. The goal of StepTalk is to make existing operating environments look like a Smalltalk environment where applications are objects. StepTalk is not another implementation of Smalltalk. It is more of an object abstraction layer over Objective-C applications and distributed objects. Applications behave like any other objects in the environment. The purpose of the StepTalk project is to glue both applications and distributed objects along with the framework into a single environment and to allow users to communicate with the objects in different languages. Smalltalk is one of those languages.

The Classbox Model is an extension to the OO paradigm bringing in a powerful modular development. It allows to reuse and extend some code under a modular unit, named Classbox. A Classbox is an unit of scoping composed by some class imports declarations and by definitions of class and method.

Only classes can be imported. The granularity of the import clause can be unitary (a classbox can import classes one by one) or by whole Classbox (a classbox can import all the classes defined by an another classbox). The scope of a classbox is the classbox itself. This mean a classbox can add or redefine any method of a class without breaking any client of the imported classes.

One strength of the model is a class extension offered by a classbox is not simply a new layer put in front of the formally code: The formally and new code can interact each other without any restriction. A validation is made in Squeak using a modified virtual machine. In order to have a complete model and some acceptable performance the method lookup need to take the scope into account.

The talk will be followed by a demonstration.

Benchmarking and comparing distributed environment is generaly very difficult task. In order to make it a little bit easier and to set a certain level of standard measurements, we developed automated framework for such purposes. This tool enables users to start a selected measuring task on a group of computers and to see results immediately on the screen. When all computations are finished results are saved in severaral forms to files in dedicated directory - currently postscript, pdf, html + gif images are supported. Environment supports compex measurements concerning transfer rate of simple data types, ordered collections and hierarchical structures. It is also testing limits and behaviour of naming service and life cycle registration. Environment is quite general, it is supplied with methods performing actual sending for different distributed interfaces. Currently Cincom DST, Cincom I3 and C++ Mico are matter of subject. In the future it will include OpenTalk and Gemstone as well. Intend of the whole work is to get quickly overview of the behaviour and limits of selected distributed system interface on a particular configuration.