Fifth ESUG Smalltalk Summer School
August 25 - August 29
Sophia Antipolis, France

Monday August 25th
Components and Business Objects

9.15 Welcome introduction
9.30 - 11.00 T1: Building components in Smalltalk
Joseph Pelrine, Object Solutions, Switzerland
11.00 - 11.30 Coffee break
11.30 - 13.00 T1: exercises
13.00 - 14.00 Lunch
14.00 - 15.30 E1: Component objects
Jurgen Nicklisch-Franken, Claas Solutions, Germany
15.30 - 16.00 Coffee break
16.00 - 17.30 E2: Objects to Test Objects
Ernest Micklei, ELC Object Technology, The Netherlands
17.45 - 18.30 Attendees' demonstrations

Tuesday August 26th
Object Management Tools

9.00 - 10.30 T2: Toolsmithing \-- Who, When, and How
Jan Steinman, Bytesmiths, USA
10.30 - 11.00 Coffee break
11.00 - 12.30 T2: exercises
12.30 - 14.00 Lunch
14.00 - 15.30 P1: Envy software Quality Assurance Tools
Philippe Krief, OTI, France
15.30 - 16.00 Coffee break
16.00 - 18.30 Panel/Workshop
20.00 Special Dinner

Wednesday August 27th
Distributed Objects

9.00 - 10.30 P2: IBM Distributed Smalltalk
Marc Gardette, IBM, France
10.30 - 11.00 Coffee break
11.00 - 12.30 E3: Distributed objects
Wolfram Marwik, Switzerland
12.30 - 14.00 Lunch

Thursday August 28th
Reusability in Smalltalk

9.00 - 10.30 T3: Reuse Contracts as a basis for investigating reusability of Smalltalk code
Koen De Hondt, Vrije Universiteit Brussel, Belgium
10.30 - 11.00 Coffee break
11.00 - 12.30 T3: exercises
12.30 - 14.00 Lunch
14.00 - 15.30 E4: A Printing Framework in VisualWorks
Martial Dore, Ingenia, France
15.30 - 16.00 Coffee break
16.00 - 17.30 R1: MOOSE
Serge Demeyer, Stephane Ducasse, Bern University, Switzerland
17.45 - 19.15 R2: Improving Design Using Dynamic Class Change
Noury Bouraqadi-Saadani, EMN, Nantes

Friday August 29th
Smalltalk and Internet

9.00 - 11.00 T4: Integrating Smalltalk and the Web (part 1)
Adrian Kunzle, JP Morgan, USA
11.00 - 11.30 Coffee break
11.30 - 12.30 T4: Integrating Smalltalk and the Web (part 2)
Adrian Kunzle, JP Morgan, USA
13.00 - 14.00 Lunch
14.00 - 15.30 E5: VisualWave and Javascript
Claude Delaye, Ingenia, France
15.30 - 16.00 Coffee break
16.00 - 17.30 R3: Smalltalk to Objective-C translator
Dietmar Gellerman, Germany


T1- Building components in Smalltalk
Joseph Pelrine
Object Solutions, Switzerland

Building components in Smalltalk. Using techniques learned from (among other things) PARTS and VisualAge to build lean and mean reuseable subsystems and components in pure Smalltalk.

T2- Toolsmithing \-- Who, When, and How
Jan Steinman, Bytesmiths

An interesting thing about working in the Smalltalk environment is that you can modify the tools you buy from the vendor, or even build new tools. Many experts counsel their clients to buy tools instead of building them. Based on over 10 years of working in Smalltalk as tool builders (among other things), we can help you with the decision process, and with a myriad of suggestions based on our many projects' experiences. The "who" will help you decide whether to build or buy, the "when" will cover timing issues, and the "how" will provide some hard-learned do's and dont's.

T3-Reuse Contracts as a Basis for Investigating Reusability of Smalltalk Code
Koen De Hondt, Vrije Universiteit Brussel

\* Topic
A well-known problem with frameworks is that they are difficult to extend. One needs quite a detailed understanding of the implementation of framework classes in order to know how they should be subclassed. Today, the only available strategy to acquire that understanding is source code inspection. Reuse contracts [1] were introduced by Steyaert et al. [2] to get rid of this error-prone process. The idea is that a framework developer documents that part of the design of a framework that is relevant to application developers, while an application developer declares how the framework is actually reused. In their current state, reuse contracts document how a class reuses itself (through self sends) and how it reuses other classes (through inheritance and messages to instances of other classes). The formal nature of the documentation ensures that one can reason about the reuse contracts and that they can be put to work in a development environment. Experience has shown that reuse contracts in their current form are valuable to perform effort estimations when a framework is to be customized, to analyze the impact on customizations when a framework changes, and to guide the developer in the customization process. On top of that, reuse contracts can be extracted from source code, so that they can be used to investigate the design of a framework and to detect bad designs.

\* Goal to achieve:
The goal of the tutorial is to expose the participants to reuse contracts as a way to cope with the difficulty of reusing object-oriented software components. It stresses the importance of formal documentation to be able to reason about reuse at the design level instead of the implementation level.

\* Outline:
  • Detailed explanation of the concept of reuse contracts
    • Single-class reuse contracts (reuse contracts for inheritance)
    • Multi-class reuse contracts
    • Notation
  • Reuse contracts at work
    • Code generation when subclasses are created
    • Effort estimation for framework customization
    • Impact analysis when a framework changes
  • Extracting reuse contracts from Smalltalk source code
    • Examining a class hierarchy
    • Spotting bad designs in a class hierarchy
  • Reuse contracts in other contexts: components, design patterns, ...

During the exercises part of the tutorial the participants use a reuse contract extractor tool to investigate frameworks. The participants are invited to bring the source code of their own (VisualWorks) Smalltalk frameworks/class hierarchies, so that they can investigate their own programs.

The reuse contract home page is

T4- Integrating Smalltalk and the Web
Adrian Kunzle

\* Topic
This session looks at the different ways Smalltalk can participate in the Web revolution. It starts with an overview of what the Web is from an application perspective, and then goes on to talk about three different products, available today, that can be used to deploy Smalltalk applications over the Web. These are ParcPlace-Digitalk's VisyalWave, IBM's VisualAge for the Web and Classic Blend from Applied Reasoning. The session concludes with a discussion on the use of the Web as a distributed object space, and how Java, CORBA and Smalltalk can help us with application development in the future.

\* Goal to achieve
The audience should leave with a good understanding of how the Web works, and how applications can interact with the world of the browser. They should also be aware of the issues of taking a traditional, single-user Smalltalk application and converting it to run on a server with multiple, concurrent users. The third goal is to generate thoughts and discussions about the future of the Web, Java and Smalltalk, and how we can shape the way we develop solutions.

\* Outline
  • What is the Web
  • Server issues
  • Vendor solutions
  • The future and discussion

Experience Reports

E1- Component Objects -The next generation of really portable business objects by modelling relationship as a higher unit
Juergen Nicklisch-Franken, Claas Solutions, Germany

This talk starts with looking on the relationship of object-oriented and component technology. Our thesis is that both technologies have their own aim and realm. We explore how both approaches can be merged. We propose to give components an impact in the phase of oo-design, and reason that the restriction of this impact, even can give oo-design a better quality. We have done prototype studies for implementing the technical requirements in Smalltalk, but standard technologies like Java beans or Active-X components, will be usable for implementation. The talk should be more a theme of general interest, and it has even more a philosophical touch, then to dwell in technical details.

E2- Objects to Test Objects
Ernest Micklei, ELC , The Netherlands

As objects evolve during the development life cycle and the fact that objects will interact with lots of other objects, the need for automatic testing is risen. In a project where hundreds of objects will be defined and integrated by different team members, the management of individual tests and, even more important, the integration tests will become very difficult without a tool to keep track of the dependencies between methods and to ensure they evolve along with the objects themselves.

By viewing tests as objects, the basic unit is called a test-case which has a name and holds a test-script that represents the evaluation program. An important part of the concept is the notion of composing tests from (other) test-cases. Besides the ability to control the order in which parts of a test are runned, the composition also controls the flow of objects passing from one test to another. This cascading approach enables the tester to compose new tests by specifying which test-cases should be pre-runned and which are required to be run after running the script. Because the composition of tests is done at the object level, dependencies between test-cases can be minimized thus resulting in a higher degree of reusability of test-cases. Test-cases may store reference objects that can be compared to test-results automatically. This talk will present this testing approach highlighting significant differences and demonstrating some tools used in a project.

E3- Distributed Objects with an Object-Distributed-DBMS
Wolfram Marwik, Switzerland

Distributed objects need a stable technical foundation, which hide the complexity of the hardware and software protocols of the involved systems. We will talk about these foundations and show how distributed objects will lead to well structured applications which would be extremely difficult to develop in conventional client-server or host based systems.

Distributed objects can bring consistent order to data held on multiple levels. They can also offer an integrating perspective which lets to cooperate software developed in different languages and systems. The foundations and requirements for Object-Distributed-DBMS systems will be presented.

E4- A printing framework in VisualWorks
Martial Dore, Ingenia, France

We will first show how a window is built in VisualWorks (by a pattern-oriented presentation of the various "actors" -classes- involved in this process). Then we draw a parallel between a window and a (generated) document.
Practice : We make it concrete by subclassing the existent abstract classes and running it !
Purpose : The well distributed responsibilities of an existent framework and the concrete reuse of it (and its "patterns") show the benefits of a plain OO approach : reusability & extensibility.

E5- VisualWave and Javascript
Claude Delaye, Ingenia, France

We want to illustrate how to use VisualWave and Javascript to obtain a local control of entry fields and an ergonomic environment(with contextual help,error messages ...) for entry forms. We will show how it is possible to generate Javascript and Smalltalk control to obtain the same capabilities in Smalltalk environment and under an internet navigator. A subtopic is to show how it is possible to integrate VisualWave generated HTML pages into an allready existing internet site (calling a VisualWave page from a HTML page ; calling Smalltalk and passing parameters from an ordinary HTML form).

Research Aspects

R1- MOOSE: A language Independent Re-engineering Environment
Serge Demeyer, Stephane Ducasse, Bern University, Switzerland

The ability to re-engineer object-oriented legacy systems becomes a matter of life or death in today's software industry. All of the early adopters of the object-oriented programming paradigm are nowadays facing the problem of transforming their object-oriented "legacy" systems to full-fledged frameworks. Dealing with programs exceeding 10,000 lines of poorly written and badly documented C\+\+ code definitely requires tool support.

We present MOOSE, an environment that helps a software engineer during the model capture and problem detection phases of re-engineering projects. MOOSE is able to support these tasks because it is based on a conceptual representation of the legacy system that surpasses traditional text. Among others, such a conceptual representation allows one to express hypotheses about the legacy system in a query language that is based on object-oriented concepts (classes, methods, objects, ...).

MOOSE employs the full facilities of Smalltalk programming environments, but the environment is language independent and has among others been used for legacy systems written in Smalltalk, C\+\+ and Java. MOOSE is an open environment, meaning that it communicates with third-party applications to import and export the necessary information. As an example, we import information from the symbol tables maintained in the SNiFF+ C+\+ environment and export to public domain graph lay-out tools and spreadsheets.

MOOSE is used on real case studies provided by the industrial partners of the FAMOOS Esprit project.

More information about the authors:
about the FAMOOS project:

R2- Improving Design Using Dynamic Class Change
Noury Bouraqadi-Saadani, Ecole des Mines, France

OO programming is a two-sided task : design and implementation. Application designers often highlight the evolution of object behavior using state-transition diagrams (OMT, OOD, OOSE). But, class-based languages - including Smalltalk - do not easily address behavior evolution at runtime. Thus, in order to work out such designs, implementors use constructions such as the "State Pattern" [Gamma et al.]. This pattern allows an object to appear to change behavior, but only within a certain frame that restricts evolutions.
In order to bridge the gap between design and implementation, we suggest to relax "the constraint of immutability" usually put on the instanciation link. Object evolution is achieved by allowing dynamic class change. As a result, the consistency of class hierarchies is improved, the reuse of components is magnified, maintenance cost is lowered and code readability is enhanced. Applications become more reliable as the implementation of a given design becomes easier to achieve.
Dynamic class change is provided by a class library usable by designers/implementors within their current Smalltalk.

Dynamic class change is provided by a class library usable by designers/implementors within their current Smalltalk system.

R3- Smalltalk to Objective-C translator
Dietmar Gellerman, Humboldt-Universitaet zu Berlin, Institut fuer Informatik, Germany

Smalltalk has been facing new challenges in the last years due to an increased demand of resources. Since computers have become ever faster and more powerful for less money, developers have been able to implement applications with Smalltalk via rapid prototyping. But the user faces the problem that simple applications require big resources. We want to address this problem via a compiler that translates the Smalltalk sources to a stand-alone program. We extended the "Producer" translator by Brad J. Cox for this purpose. Cox implemented an object-oriented message system with Smalltalk-like features as an expansion of C, called Objective-C. His implementation of the "Producer" translates a subset of Smalltalk to Objective-C.

However, some features of Smalltalk do not have an equivalent in Objective-C and, therefore, could not be handled by the translator. A lot of problems remain to be solved for a complete Smalltalk to Objective-C compiler. Instead of using Cox's base of the compiler, we modified the system to work with the GNU-Foundation library. This library is being developed for Openstep, a variant of NeXT-Step. The library is a base to other libraries for GUI- and DPS-systems. We have been working on connecting the base classes of Smalltalk with these libraries. The talk will present the translation of a small example. We focus on the main problems, namely the handling of data-types, which are necessary in Objective-C, and blocks that do not exist in Objective-C. Blocks are handled as nameless functions. We have implemented the principle of lambda-lifting in the translator, which is well-known in the context of functional programming. In the presentation we intend to demonstrate the compilation process and what its applications on the user level.

Product Presentations

P1- Quality Assurance with Smalltalk
Philippe Krief, OTI, France

We present in this tutorial some of the principal rules to provide a quality code. These rules concern:

  • project management
  • class/application organization
  • code of methods
We will introduce Envy/QA, which runs on VW and VA, to explain some of these rules. We will also present how to use this kind of tool (Code Critic, Code Metrics, Code Coverage, Code Formatter and Code Publisher) during each step of a project development.

P2- IBM Distributed Smalltalk
Marc Gardette, IBM, France