Program

Sixth ESUG Smalltalk Summer School
August 31 - September 4
Brescia, Italy

Day

Time

Morning

Time

Afternoon

Monday
August 31

9.00-
12.30

Architectures and Techniques for Building Server Objects (Tutorial with exercises)

Jay Almarode

14.00-
15.00

Why Object Relational Databases and Object Transaction Monitors are going to change the way we build systems. An example architecture: Monza.

Jason Ayers

     

15.00-
16.30

Developing a client server system with VisualAge for Smalltalk and VisualAge for Pacbase, the perfect road from Cobol to Smalltalk !?!

David Grietens

     

16.30-
17.00

Discussion

Tuesday
September 1

9.00-
12.30

Refactoring Techniques and Tools

Don Roberts & John Brandt

14.00-
15.00

Visual programming: prototyping versus development (experience report)

Anna Ottobelli

     

15.30-
17.30

*Commercial demos>demos* (CINCOM, IBM, ...)

Wednesday
September 2

9.00-
10.00

Squeak

Ian Piumarta

 

Free - possibly we will go touring the Italian lakes!

 

10.30-
12.30

Squeak: practice, discussion, VM implementation for people who will be interested

   

Thursday
September 3

9.00-
10.00

Fuzzy Logic

L. Schiavina

14.00-
15.00

Patterns And Quality - What Is The Link?

Andy Berry

 

10.00-
10.30

Discussion

15.00-
15.30

Discussion and questions

 

11.00-
12.00

Temporal Objects in Smalltalk

Joachim Geidel

16.00-
16.30

Rolemodeling - A method to design and reuse patterns for system modeling

Peter Werner

 

12.00-
12.30

Discussion and questions

16.30-
17.00

Discussion and questions

Friday
September 4

9.00-
10.00

Cancelled!
Assuring plausibility in insurance applications.

 

Markus Arikan

14.00-
15.00

From design to implementation of interactions : an Environment in Smalltalk

M. Fornarino & A.M. Pinna

 

10.30-
11.30

Object Connect - Performance Techniques

Tarik Kerroum

15.15-
17.00

*Demos from attendees>demos*

Discussion

 

11.30-
12.30

Discussion and questions

   

Summaries (in chronological order)

 

Jay Almarode: Architectures and Techniques for Building Server Objects

Gemstone

Abstract

This talk compares the pure client/server model with the 3-tier model and describes the features required of Smalltalk to act as the application server. We discuss application partitioning and give general rules and examples of how to partition. We describe the principles and techniques for building server objects, focusing on concurrency control and transactions.
We examine three ways to manage concurrency: pessimistic, optimistic, and semantic concurrency control. For pessimistic concurrency control, we describe the kinds of locks and discuss design choices for when to acquire locks. For optimistic concurrency control, we describe a framework for replaying operations when conflict occurs. We also describe the theory of semantic concurrency control, and present a detailed exercise of building a high-concurrency array.
In discussing how to support transactions, we compare how different architectures support the ACID properties. Two main ways to support transactions are to interface to an external database that supports transactions, or to enforce transaction properties in the virtual machine itself.
If time permits, we will also discuss security and fault tolerance.
When building secure server objects, we distinguish between authentication and authorization. We focus on authorization, and discuss different ways to control the reading and writing of objects, and show different techniques for limiting which users can execute methods. We discuss two main areas of fault tolerance: recoverability and availability. Recoverability can be achieved by performing on-line backups of object memory, writing transaction logs, and checkpointing the state of object memory. Availability can be achieved by maintaining two copies of object memory, building warm backup systems, and by building replication servers.

The talk is intended to be a 3 hour, tutorial presentation with class exercises. The class exercises are as follows:

  • Application partitioning exercise 1: (5 minutes)
  • Assign various objects and methods to 1st tier (client) or 2nd tier (server).
  • Application partitioning exercise 2: (10-15 minutes)
  • Given a server object model, design replication specifications for how objects should be created on the client.
  • Concurrency control design exercise: (20-25 minutes)

The class will interactively design a highly concurrent Array class (multiple concurrent users can update the array without conflict or loss of consistency).

Bio

Jay Almarode has been creating object-oriented systems since 1984, first with General Electric, and later with Digitalk and GemStone Systems, Inc. He wrote his first Smalltalk code in 1986, building a rule-based delegation system for his graduate research. Since then, he has built CASE tools, interfaces to relational and object database systems, query and indexing systems, multi-user classes featuring semantic concurrency control, and federated distributed object systems in Smalltalk. He is currently a principle engineer at GemStone Systems, Inc. He has written columns for The Smalltalk Report, as well as published in Object Magazine, JOOP, Dr. Dobb's, and OOPSLA and ECOOP conferences.

Address

almarode@gemstone.com

 

Jason Ayers: Why Object Relational Databases and Object Transaction Monitors are going to change the way we build systems. An example architecture: Monza.

Abstract

This year is going to see the arrival of two major new object technologies that will transform the way that we go about building object systems: Object Relational Databases and Object Transaction Monitors.
In most business systems today there is generally about 20-30% of the data structures that would benefit from a navigational recovery mechanism or the ability to store complex types in the database. Today these data structures are forced into a relational db because there is little other choice. OODBs remain a costly and unattractive option for many and always represent a major technology commitment. Object Relational Databases allow us to represent to 20-30% of our data in an object based manner with effective navigational recovery. The remaining data can remain in a relational storage environment within the same database. OR dbms provide real object support with a low cost entry point.
As people put their systems on the internet/intranet they must provide the same kind of transactional support that their mainframe based systems have had for years. This TP support must interface seamlessly with the object technology that they are using. The need for TPMs on the internet is vast. This is a technology that once we have it we will wonder how we ever lived without it.
Monza is an example of an architecture combining both technologies.
ObjectShare is a Smalltalk and Java technology vendor.

Bio

Jason Ayers is ObjectShare's Director of European Professional Services based in Farnham, Surrey, UK. He has 10 years experience in building OO technology systems largely in the Smalltalk arena.

Address

Jason Ayers
ObjectShare (U.K.) Ltd.
tel: \+44 (0)1252 719100
fax: \+44 (0) 1252 719200
jayers@objectshare.com
Waverley House, Farnham Business Park,
Weydon Lane, Farnham, Surrey, GU9 8QT, UK
http://www.objectshare.com/

 

David Grietens: Developing a client server system with VisualAge for Smalltalk and VisualAge for Pacbase, the perfect road from Cobol to Smalltalk !?!

Abstract

This talk will report on a project that was performed for an important belgian company where VisualAge for Pacbase and VisualAge for Smalltalk were used to implement a typical client server system (one of the first projects in the world that used this technology). What was not so typical about this system is that objects were created in pacbase (an run on the server / old server technology) and these objects are accessed from the smalltalk world by using proxies. Several decisions had to be made of where to do what (client or server). Also a migration from classical structured analysis methods to object oriented methodologies was an important issue and questioned in many ways the added value of OO analysis and OO design. This talk will explain the technology; its usefullness and how it was implemented in a team of classic 'cobol' developers.

Bio

David Grietens has been a software architect since 1987 after finishing his studies in computer science at the University of Brussels (VUB). He is involved in commercial Smalltalk projects since 1990 and since 1994 he is the owner of hIghQ, bvba, a company that concentrates on improving the quality of custom made software, by professionalism and respecting user requirements.

Address

David Grietens
hIghQ, bvba
Karekietenlaan 49 B1
B-3010 Leuven
Belgium
e-mail: david@highq.be
web: http://www.highq.be

 

Don Roberts & John Brant: Refactoring Techniques and Tools

Abstract

Refactoring is generally agreed to be a necessary part of the OO software lifecycle. However, it has been woefully unsupported when it comes to tools and methodologies. This course will examine refactoring and show how to integrate it into your development. We will look at several of the barriers to refactoring and how to overcome them using both standard development tools and specialized refactoring tools.

Another portion of the course will discuss the implementation of refactoring tools. Such a tool for Smalltalk, the Refactoring Browser, will be used to demonstrate those principles.

Additionally, we will look at the refactorings themselves. Where they come from, and how they fit with design patterns.

Our discussion of refactoring will use Smalltalk for most of the examples, but the principles will be applicable to most OO languages.

Outline

  1. Philosophy of Refactoring (45 minutes)
    1. Software Maintenance
    2. Evolutionary Development
    3. Refactoring
      1. What it is
      2. Where they come from
    4. Barriers to refactoring
      1. Schedules
      2. Complexity
  2. Tactics for Refactoring (60 minutes)
    1. Common Refactorings
    2. Refactoring using the Standard Tools
    3. Refactoring Tools
      1. Properties of a Refactoring Tool
      2. The Refactoring Browser
  3. Strategies for Refactoring (60 minutes)
    1. Smalltalk Best Practice Patterns
    2. Design Patterns
  4. Conclusions (15 minutes)

Duration: half-day

Level: Intermediate

Required experience: Attendees should have at least a year's experience with developing software in some OO language.

Expected audience: Developers and Managers. Attendees will learn how to keep their OO-designs evolving while still meeting production deadlines.

Bio

John Brant and Don Roberts are Smalltalk consultants and PhD students at the University of Illinois. They have been studying refactoring with an emphasis on building tools to help developers restructure "real" Smalltalk programs.

Tutorial resume: A shorter version of this tutorial was presented at Smalltalk Solutions '97 in New York City, NY. While there were no formal reviews, it appeared to be received enthusiastically.

Addresses

Don Roberts (contact)
Department of Computer Science
University of Illinois
1304 W. Springfield Ave.
Urbana, IL 61801
droberts@cs.uiuc.edu

John Brant
Department of Computer Science
University of Illinois
1304 W. Springfield Ave.
Urbana, IL 61801
brant@cs.uiuc.edu

 

Anna Ottobelli: Experience report

Abstract

Forthcoming.

Address

ottobell@vnet.IBM.COM

 

Ian Piumarta: Squeak

I could talk about:

  • the system as a whole \+ the "neat" things that various people are doing with it [not very technical]
  • the implementation (the VM is written entirely in Smalltalk) [a bit technical]
  • how Squeak was ported to Unix [fairly technical, but probably also fairly boring]
  • the work that I've been doing with Dan Ingalls and John Maloney on implementing a new "just-in-time" compiler for Squeak (also written entirely in Smalltalk) to speed up the performance [very technical]

Address

piumarta@prof.inria.fr

 

Lorenzo Schiavina: Fuzzy objects

Abstract

Fuzzy objects are normal smalltalk objects which are capable of exhibiting fuzzy behaviour instead of the crisp behaviour which is typical of smalltalk objects derived from standard classes.  Fuzzy objects are derived from a class which implements attributes common to fuzzy sets, and thus its behaviour towards the user is fuzzy;  from this class a new hierarchy can be created, in parallel with the standard one when necessary, and therefore it is possible to generate fuzzy objects which mix with normal crisp objects.

In the presentation the following points will be covered:

  • very brief introduction to the theory of fuzzy sets,
  • VisualAge Smalltalk definition of a new hierarchy that implements fuzzy behaviour with the objective of demonstrating the capacity of objects to crystallise knowledge and to be used naturally by users lacking technical skills
  • example of fuzzy objects controlled through a process of fuzzyfication/defuzzyfication which is typical of fuzzy expert systems.

Bio

Lorenzo Schiavina is a professor of operations research in the mathematics faculty at the Catholic University of Brescia. Additionally Lorenzo is president and founder of EDOR M. Q., a Milan, Italy, based IT company specialised in object technology and with a strong preference for Smalltalk.  EDOR has been a ParcPlace-Digitalk Italian distributor, and since 1996 has been IBM's Italian Business Partner for VisualAge Smalltalk.

EDOR is certainly Italy's strongest promoter of Smalltalk.

Address

lorenzo@edor.it

Since he never seems to read his E-mail, the better contact address seems to be:

Darin McLean
EDOR
tel. 39-2-2155096
fax 39-2-2153598
mobile 39-348-2323227
edor@compuserve.com)

 

Andy Berry: Patterns and quality: what is the link?

Abstract

This paper will consider several issues relating to quality of software and patterns.

It will begin by asking what makes a useful pattern. It will include examples (gathered from pattern repositories on the Web) of patterns that are helpful and others that are less so. It will show that less experienced developers of patterns sometimes seem to be writing unusable pearls-of-wisdom rather than reusable patterns with identified areas of application.

It will propose that patterns are not applicable to all problems but suggest the existence of a "universe" of problems that patterns can help to address. It will suggest that the Gang-of-four probably had this universe in mind in their book.

It will show how the application of patterns can help and hinder the development of quality software. It will show that the flexible application of patterns can help capture best practice but that the rigid application of a limited number of patterns can cause the finished software to lack the essential QWAN ("Quality without a name") that makes great software - it can make it feel "wooden".

It will then discuss mechanisms to ensure the software development process incorporates the "spirit" of the patterns chosen for a project, rather than just the details of particular patterns. This will include discussing the need to ensure that patterns guide rather the drive software development. It will cover issues relating to training of software developers, mentoring and monitoring and propose that project should formally test patterns before they are added to the repository of patterns.

Address

Andy Berry - The Object Factory ( http://www.tof.co.uk )
andy@tof.co.uk

 

Joachim Geidel: Temporal Objects in Smalltalk

Abstract

In many information systems, time related information has to be stored and processed.
There are two categories of such information: information about real world events and the history of real world objects, and information about additions to and deletions from the information stored in the system itself. After a short review of some basic ideas and work from research on Temporal Databases, the design and implementation of a Smalltalk framework for temporal objects is shown. The design is based on an implementation from a project at the Swiss National Bank. The presentation also shows some preliminary work on adding support for temporal objects to the Smalltalk class library which lets it appear as an integral part of the environment.

Bio

Joachim Geidel is a consulting engineer and trainer at Daedalos Consulting GmbH, located at Witten, Germany. He has been working with Smalltalk since 1989 in university projects, as technical support engineer, VisualWorks and ENVY trainer, and as consultant in industry projects. He is a co-author of two introductory books on Smalltalk programming with ObjectWorks and VisualWorks.

Address

Joachim Geidel
Daedalos Consulting GmbH
Wericastrasse 13, D-58456 Witten, Deutschland
Tel.:  +49-2302-979-0  Fax: +49-2302-979-199
Email: Joachim.Geidel@daedalos.de WWW: http://www.daedalos.de

 

Peter Werner: Rolemodeling - A method to design and reuse patterns for system modeling

Abstract

What is a Role and an Aspect. Basic ideas and relations to: Object-orientation, Aspect-orientation, Pattern, Visual-Modeling. The syntax of the language. Examples and demonstration. What I've learned as I've developed a prototype-tool in Smalltalk.

Bio

My name is Peter Werner. I'm a mathematicion and work as a staff scientist in the Deutsche Telekom AG in the Technologiezentrum in Berlin. Since the early 90th I use Smalltalk/VisualWorks. Since 95 I've together with my colleagues contact to some norwegian company.

Address

Dipl.-Math. Peter Werner
Deutsche Telekom AG, Technologiezentrum
P.O.Box 113, D-10108 Berlin
Goslarer Ufer 35, D-10589 Berlin
Phone: \+49 30 3497 4320
Fax: \+49 30 3497 4975
E-mail: werner@tzd.telekom.de

 

Cancelled!
Markus Arikan: Experience report - Dynamic and Transparent Configuration of Notebook Pages.

Summary

Modern life-insurance companies typically offer a wealth of different products, which are coupled with optional add-ons like accident-insurance. Necessary input for calculation is always based on product selection, so a notebook-style view has to change according to product selection. How this configuration and reconfiguration is done will be shown in the experience report, based on work done for one of my clients.

Abstract

I have done consulting for a large german life insurance company the last year. We have build an application for their sales force to calculate and print policy offers with VAST. It was the companys first OO-Project and it was a success. We have done extensive work regarding so called plausibilities and error handling. Also we have a Notebook which is dynamically configured and reconfigure depending on the chosen product.

So there are two possible technical themes:

  1. Assuring plausibility in insurance applications.
  2. Dynamically configuring Notebook Parts.

Since no project is perfect, we also faced problems. Mainly they were related to the processes. This year I am involved in process improvement consulting for the same company. Possible themes:

  1. Introduction to SPI (Software Process Improvement)
  2. Introduction to the V-Modell 97 (German governmental standard for system development)
  3. Introduction to the Personal Software Process.

Address

Markus Arikan Private Site in Karlsruhe/Germany
E-Mail:
markus@arikan.inka.de
Phone: \+49-172-7207118

 

Anne-Marie Pinna-Dery: From design to implementation of interactions : an Environment in Smalltalk

Objects communicate and interact by message sending.
Since the design step, UML allows to express the interactions in static and dynamic diagrams. However at the implementation level, the interactions are often mixed inside the code of the object methods. Checking the consistency and understanding the interaction network is then difficult.
So works in reengeneering for example propose to detect the interactions at execution time. Our approach differs in that we propose to take into account the interactions at design level and to keep them outside of the objects at the implementation level. The technic used according to the language is always based on message catching. We experimented our approach in different languages (Clos, Smalltalk (of course), Orbix/C\\\+\+ and Open-C\\\+\+) and doing so we conclude that in fact the interactions are an aspect for object oriented languages in the sense of the aspect oriented programming proposed by Kiczales.
Indeed the description of interaction using only the object interface is independent of the aimed object oriented languages.
An environment of development based on the interactions from design to implementation has been developped in Smalltalk and we propose to present it.
In this presentation we will show how we can describe interactions. We will then discuss how such a formalism allows to check some properties such as cycle detection, concurrent acces to shared data, synchronisation points, ...
We will then present the development environnement for Smalltalk : Describing how we can determine the class of the objects involved in the interactions and structure the classes by inheritance. Such an approach helps in the use of the library and the organization of knowledge. We will then discuss the code generation in Smalltalk.
In conclusion, we will present the generation of code for Corba-C\\\+\+ by extrapoling typing from objects at execution time.
In the scenarii, interactions are expressed as a sequence of messages. If a message is sending, we have to expect the following messages. In the collaboration diagram, the order of the message is clearer, ... In the state diagram, in the same time we can expressed that some message are not acceptable in some state and expressed which messages are emit. Finally the object diagrams expressed the existence, the cardinality, some properties of the association and in the same way of interactions.

Addresses

pinna@essi.essi.fr
blay@essi.essi.fr

 

Tarik Keroum: Performance Techniques

Abstract

The presentation discusses the different aspects involved in performance tuning. It first addresses performance metrics; how performance data can be measured effectively. The factors influencing the performance of an application will be presented.
Performance tuning occurs at two stages. The compiler re-arranges the code so that it optimizes application performance automatically. The second stage involves the developer; he or she can rewrite performance sensitive areas for better performance. The basis for performance tuning consists of profiling data.
GUI feedback is a related topic, since the idea here is to give the user of a system a clue about the progress so that a lenghty process looks faster than it really is. Different techniques to use background processing are discussed as well.
Memory management is often an important consideration, since it may generate unwanted activity and increased memory consumption. Profiling data lets the developer pinpoint allocation peaks, and alternate allocation techniques can provide a boost in performance or simply let an algorithm on very large data sets.
Tuning examples will focus on comparisons between regular Smalltalk, inlined Smalltalk messages, C and assembler, and when to stop looking for performance improvements.

Address

Tarik Kerroum
Object Connect
tarik@objectconnect.com