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
- A reflective model for applying programming
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.
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ón (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.
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.