About Esug

General Information

Call for Contributors

Technical Program
Academic Track

Social Event




Contact information

Important Dates

Student Volunteer

Past conferences

Program Schedule

Coffee break
Social Event
Coffee break + Talkussions
Coffee break + Talkussions


Invited speeches


Invited Speech: Puncturing the Balloon. Re-inventing and Selling Smalltalk in the 21st Century - Joseph Pelrine (MetaProg)


In the last millenium, Smalltalk was the most innovative programming language around. Besides being instrumental in giving us artifacts like menus, windows, etc., it served as a tools for inspiring ideas and concepts such as Responsibility-Driven Design, test-driven development and eXtreme Programming.

The 21st century is different, though. The market has changed, while Smalltalk hasn? and now the vendors are forced into a catch-up game, having to react instead of being able to act. In addition, many Smalltalkers are incredibly resistant to any change, and still long for the halcyon days of yore.

Even the Concorde has been retired, and yet we're still putting around in that old balloon something has to change...

Joseph Pelrine is C*O of MetaProg, a company devoted to increasing the quality of software and its development process. He has had a successful career as software developer, project manager and consultant, and has spoken about it at such diverse places as IBM, OOPSLA and the Chaos Computer Club. Having survived working with Kent Beck, he currently works with Dave Simmons on and in SmallScript when he's not helping his clients solve their problems.
Invited Speech: Building Robust Embedded Software - Lars Bak (OOVM ApS)

Developing software for small embedded systems has until now been very static. Source code, written in C, is compiled and linked on the development platform and the resulting binary image is transferred onto the device. In an industry where robustness is paramount and dynamic software updates are required this is simply not good enough. This presentation will introduce a new programming platform for developing embedded systems based on Smalltalk. At the bottom of the software stack we have replaced the operating system with an object-oriented virtual machine. Scheduler, interrupt handlers, device drivers, networking code and application software execute on top of this virtual machine. We will discuss the underlying technology that is behind this dynamic, lean
and mean object-oriented system:

  • A new bytecode set designed for performance.
  • A simplified and efficient synchronization mechanism.
  • A reflective model for applying programming changes remotely.

The virtual machine, basic libraries, scheduler, network drivers run in less than 128Kb of memory. In addition to being compact, our system solves many of the existing problems, allowing dynamic software updates and full serviceability. We will conclude with a demonstration of the OOVM system, including footprint and performance numbers.

Lars Bak received an M.S. degree in computer science from Aarhus University in 1988 and has ever since designed and implemented object-oriented virtual machines. Prior to founding OOVM, Lars worked on: CLDC HotSpot, the Java HotSpot virtual machine, Strongtalk, Self and the Mjølner Beta System. Lars has 9 issued and 8 pending US patents on virtual machine technology.

Invited Speech: The secret life of VisualWorks + tools - Vassili Bykov (Cincom)
Invited Speech: Ian Piumarta

Invited Speech: Dan Ingals (cancelled)

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

Invited Speech: John Brant (Refactory)


Technical speeches

Christian Haider: SmallCharts

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.

Germ?Fabregat: SmallTalk to teach Computer Architecture

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.

David Gorisek: OmniBase object database for Smalltalk

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.

Kirk Blackburn, Stan Benda, and Saogat Rab: Virtual Pair Programming

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

Lukas Renggli: SmallWiki

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.

Petr Stepanek: On the Refactoring of VW, SUnit and Store

Abstract to be communicated.

Georg Heeg: Smalltalk speaks .NET and gets mobile

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

Bonzini: AOStA: An Adaptively Optimizing Smalltalk Architecture

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.

Andrew Berry: Micro Object Testing

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.

Sandro Pinna, Paolo Lorrai, Giovanni Corriga: XPSwiki: an open source tool supporting XP Process

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.

Alfred Wullschleger: Using Smartcards for logging into Gemstone Databases

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.

Stefan Urbanek: StepTalk - Illusion of Cooperating Objects Environment

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.

Alexandre Bergel: Classboxes

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.

Jan Lukes: Framework for Evaluating Distributed Smalltalk Interface

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.


A talkussion is a discussion section about the talks held that day. The idea is to have an open forum where the invited speakers and presenters that gave a talk that day can be confronted in detail by anybody, or can show extra demoes for which they did not have time, or discuss some really low-level details for the really interested people. It can be compared to a speakers' corner at major conferences, but then behind a machine and/or a projector.

Of course, we also expect people to discuss about topics of interest, as it has always happened at ESUG conferences. People can continue CampSmalltalk projects or have other ad-hocs workshops they find interesting.