Sixth ESUG Smalltalk Summer School
August 31 - September 4
Brescia, Italy
|
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:
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
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
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
I could talk about:
Address
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:
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
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:
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:
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