Are You Agile or Are You Fragile?
keynote
Ambler, Scott: Ronin
Monday 10:30:00 am to 12:00:00 pm

Abstract: The software process landscape is changing. A shift from large-scale, prescriptive processes that define rigorous procedures and policies to lighter, more agile methodologies is clearly underway within the IT industry. This is more than an idle fad that promises to disappear next year, agile process are here to stay. Are these processes appropriate for your organization? If so, which ones should you consider adopting? What challenges can you expect to experience as you adopt these new processes and how can you overcome them?
In this presentation Scott Ambler discusses the values and principles of the Agile Alliance and shows how they are reflected in these new methodologies. He also describes and then compares and contrasts the leading agile methodologies including Crystal Light, eXtreme Programming (XP), Scrum, Dynamic System Development Method (DSDM), Feature Driven Development (FDD), Agile Modeling, and Agile Data. He also discusses the possibility of tailoring an agile instantiation of the Rational Unified Process (RUP).

Bio: Scott Ambler is a Senior Consultant with Ronin International, Inc. since its inception in 1999. He actively works with Ronin clients on large-scale software development projects and on software process improvement (SPI) efforts around the world.
Scott is Canadian and still lives in Canada although he spends a large portion of his time consulting in the United States and Europe. He has worked in the IT industry since the mid 1980s and with object technology since the early 1990s. He has written several books and white papers on object-oriented software development, software process, Agile Modeling (AM), Agile Database Techniques, the Enterprise Unified Process (EUP), and other topics.
Scott is a Senior Contributing Editor with Software Development magazine and a member of the Flashline Software Development Productivity Council. He can be reached via email at scott.ambler@ronin-intl.com 

Graduating to Objects
experience
Antion, Dan: ANI
Monday 8:30:00 am to 9:15:00 am

Abstract: A presentation of the approach taken, techniques used and results achieved training high school graduates to be object-oriented programmers.
The problem for us was finding good fulltime developers willing to work in a small shop with a limited career path. We opted to go with people who want to work in this field, but don't want to follow the traditional path. The demo in this case, is a presentation of methods and experience. Object-oriented programming (Smalltalk) poses unique obstacles to training novice programmers. Training at the high school level is sharply procedural and must be overcome. Many of the "easy" projects have already been completed and added to the class library, so carving out initial meaningful projects is a challenge.
Our success, measured by quantity and quality of products produced vs. costs and the career success of the students, indicates this approach is viable. The approach is best described as an "artisan-apprentice" relationship. Traditional formal training assumes an understanding of the business environment that doesn't exist, and self-study often leads to adoption of bad practices. In addition, we are actively working with a local high school, though their School-to-Career program, to improve career guidance and the math and computer science curriculum.
The presentation will also address in-house planning and preparation with other departments, the interview and 'contract' with the applicant, the work relationship, evaluation methods and our experience working with schools and outside agencies. Demos and technical descriptions of sample systems will be included where beneficial.

Bio: Daniel Antion is Director, Information Services for American Nuclear Insurers. He is responsible for all systems development activities in addition to managing general information technology efforts. Prior to joining ANI in 1988, he worked in systems development for several companies. He also worked as a consultant for Coopers & Lybrand and KPMG Peat Marwick, specializing in information systems and consulting services to financial institutions. He has made presentations at Smalltalk Solutions 2001 and OOPSLA 2001 and 2002.

Remote Development Panel
panel
Antion, Dan: ANI
Wednesday 10:30:00 am to 12:00:00 pm

Abstract: Remote Team Development is a panel discussion exploring the various ways different organizations approach the challenge of managing development projects with remote team members. The panel will explore the techniques used by these organizations to make remote collaboration successful. The panel will also review the technology used and the challenges that still exist.

Bio: Moderator Daniel Antion is Director, Information Services for American Nuclear Insurers. He is responsible for all systems development activities in addition to managing general information technology efforts. Prior to joining ANI in 1988, he worked in systems development for several companies. He also worked as a consultant for Coopers & Lybrand and KPMG Peat Marwick, specializing in information systems and consulting services to financial institutions. He has made presentations at Smalltalk Solutions 2001 and OOPSLA 2001 and 2002.

ReStore - Relational Persistency for the Discerning Smalltalker

Aspinall, John: Solutions Software
Wednesday 8:30:00 am to 10:00:00 am

Abstract: ReStore is a Relational Database framework for Dolphin Smalltalk which takes the novel approach of automatically generating and maintaining the database schema from the Smalltalk object model. This 'out of the box' approach allows a Dolphin programmer with little or no database experience to quickly develop applications with full relational persistency.
ReStore grew out of a recognition that the availability of comprehensive, tightly-integrated relational storage would add kudos to Dolphin as a Windows development platform, whilst allowing it to better compete with environments such as Microsoft Access.
A major design goal for ReStore was that it should have minimal impact on the Smalltalk programming experience. In addition to being highly transparent, ReStore features a Collection-like querying protocol which will be immediately familiar to any Smalltalk programmer.
This presentation will discuss the philosophy and motivating factors behind the development of ReStore, and highlight some of its distinctive features through a demonstration of its use in a number of diverse applications.

Bio: John Aspinall has been developing using Smalltalk since 1992, when he began using ObjectWorks 2.5 to demonstrate findings during a research project at Aston University, UK. Since then he has worked for commercial, banking and insurance clients on a range of systems, across all major Smalltalk dialects. He is currently working freelance for a number of smaller clients, actively using ReStore.

Test-Driven Development
tutorial
Astels, Dave: Adaption Software, Inc.
Wednesday 2:00:00 pm to 5:30:00 pm

Abstract: This will be a very pragmatic tutorial, with a mix of lecture, demonstration, and hands-on exercises. Background, tools, and techniques of TDD would be covered, as well conceptual topics such as refactoring tests, building tests around fixtures, what makes for a good test, approaches to writing tests to maximize the benefit, etc. Hands-on means programming, so make sure to bring a laptop and be prepared to pair-up.

Bio: I've been programming is some fashion/capacity for over 20 years, over 12 of that using OO. I learned OO from Smalltalk and have at least 6 yeasrs of Smalltalk experience, in areas ranging from a mass-market, shrink-wrapped CDROM series of products to natural language processing and acquisition reasearch.
I am a founding partner of Adaption Software: www.adaptionsoft.com, based in Wolfville, Nova Scotia (home of Acadia University and Ivan Tomek).
I have coauthored one book: "A Practical Guide to eXtreme Programming", and have just finished writing another: "Test-driven Development: A Practical Guide". Both titles are published by Prentice Hall.
I've recently taken over the Smalltalk port of Ward Cunningham's Fit framework (from Ward, John Brant and Don Roberts).

Using PostgreSQL from Smalltalk
presentation
Badger, Bruce: Openskills
Monday 8:30:00 am to 9:54:00 am

Abstract: PostgreSQL is a widely used open source relational database with pure Smalltalk drivers available in open source for a number of dialects. This talk will cover both the theoretical aspects of PostgreSQL (advantages and disadvantages relative to other databases, the PostgreSQL communications protocol and the implementation of the Smalltalk library) and practical (installing and configuring the database, and using it from a Smalltalk application).

Bio: Bruce Badger has been in the IT industry for over 20 years, and a Smalltalk developer for more than 10 of those. During this time he has been involved in all aspects of commercial project development and delivery, in all kinds of industries.
Over the past 5 years, Bruce has become very involved with the open source community, writing a number of open source libraries and establishing the OpenSkills association. OpenSkills provides project support facilities to it's world-wide membership of professionals, so they can focus on providing services to their clients.
To earn a crust, Bruce works on short term assignments such as training, consulting and specific development efforts. He really rather likes hard technical problems, and using the best available tools to crack them. Often, this means Smalltalk.

Experience Report
experience
Balovnev, Val: Procor LP
Monday 9:15:00 am to 10:00:00 am

Abstract: Procor LP, celebrating its 51st anniversary in 2003, manages Canada's largest private rail car rental fleet. Procor has 36 Visual Age Smalltalk applications, 24 of them are Web based. All but one are run on the intranet. All apps are business specific and cover different line of businesses including Leasing, Customer Management, Invoicing, Repair and Utility Apps. Procor Link-Net® is the Internet application developed to help increase customer control over rail transportation efficiency. It is a collection of fleet management e-tools, jointly developed with our U.S. affiliate, Union Tank Car Company that empower customers with the information they will need to easily and effectively manage rail cars.
Development environment consist of VisualAge Smalltalk, Web Connection, DB2, MQ Series, ActivPDF Toolkit, iPlanet Web Server and RightFax. Smalltalk is a part of the corporate success and we want to tell about it.

Bio: Val Balovnev is an Information Systems Professional with over 9 years experience in Business Analysis, Application Design, and Programming including 4 years full system life cycle hands on expertise in Object-Oriented Analysis/Design and Smalltalk programming in multiple environments. Specific areas of expertise include rapid prototyping, user interface design, frameworks and development for client-server and Web architecture, ENVY Management/Administration, Troubleshooting. Val Balovnev has been with Procor since 2000.

#Smalltalk Demo: An open-source Smalltalk for .NET
demo
Brant, John, Roberts, Don: Refactory
Wednesday 11:15:00 am to 12:00:00 pm

HREF Considered Harmful: Structured Web Development with Seaside
tutorial
Bryant, Avi and Fitzell, Julian: beta4.com
Monday 2:00:00 pm to 5:30:00 pm

Abstract: Dijkstra may have taught us 45 years ago that GOTO was a bad idea, but web development has barely caught up. In the CGI model of web applications, each link that is followed triggers an entirely new execution of the program. Building complex control flow out of these abrupt transitions can lead to a tangled and brittle mess of interdependent pages. Modern frameworks such as WebObjects and Struts may remove many of the difficulties of CGI scripting, but they do not escape the web's inherent GOTO: moving from one page to the next, whether through anchors, actions, forms, or forwards, is still a simple one-way jump.
Seaside is a framework for developing web-based applications that insulates the developer from the HTTP request/response loop, presenting the illusion of a continuous interactive session with the user. Each page or form acts much like a subroutine, which returns a value to its caller based on user input. Complex, conditional or looping workflows can be described in a single piece of straightforward Smalltalk code as a sequence of calls to individual pages. The benefits this brings to the reusability and maintainability of web applications closely mimick the advances made by structured programming long ago.
Seaside also sports callback-based form widgets (no manual request processing), transparent embedding of pages or even whole applications, a library of prebuilt components, and a complete web-based development environment, with code browsers, inspectors, debuggers, and profilers, all implemented in Seaside itself.
During this half day workshop, participants will be guided through building a simple business application with Seaside. Along with coverage of framework basics, special attention will be given to three topics: writing cleanly reusable pages and components, separating page logic (how an individual interaction works) from application logic (how interactions are strung together to form workflows), and proper management and support of the all-important browser back button.

Bio: Avi Bryant provides Smalltalk consulting and development services in Vancouver, Canada.
Julian Fitzell is a senior developer in the Agile Projects Group at the University of British Columbia.

Is it slow… Elastolab
experience
Buck, David: Simberon
Tuesday 2:30:00 pm to 3:00:00 pm

Abstract: Unit testing of Smalltalk user interfaces has always been a difficult task. This talk presents a GUI testing framework based on SUnit that allows GUI tests to be written in Smalltalk code. It allows the developer to write tests based on the appearance of the user interface without needing to know about widget names or subcanvases. The framework can press buttons, input text, select notebook tabs, respond to pop-up dialogs and open other windows and run tests in them. For verification, it can check the values in input boxes, radio buttons, check boxes, text boxes and tables. If these values don't match the expected values coded into the testcase, the test fails. Although there is still work to be done to support other widgets, it has allowed us to automate the GUI regression testing of about 200 testcases. The framework is being released as open source to encourage other developers to use and enhance it.

Bio: David Buck started using Smalltalk in 1984 and has been doing Smalltalk consulting work since 1994 under Simberon Incorporated. Known for his ray-tracing program DKBTrace and its derivative POV-Ray, David is also known as the key developer of the ElastoLab physics simulator for kids.

VWUnit - An Open Source Framework for Unit Testing VisualWorks GUIs

Buck, David: Simberon
Tuesday 8:30:00 am to 9:15:00 am

Abstract: ElastoLab is a program for kids that simulates physics in real-time. Since the physics in ElastoLab were originally written in C++ and later re-written in Smalltalk, ElastoLab provides a unique opportunity to compare performance between the two languages. This presentation will show objective performance comparisons between the C++ version and the Smalltalk version of the physics. It will also talk about optimizations and factors that dramatically affect performance.

Bio: David Buck started using Smalltalk in 1984 and has been doing Smalltalk consulting work since 1994 under Simberon Incorporated. Known for his ray-tracing program DKBTrace and its derivative POV-Ray, David is also known as the key developer of the ElastoLab physics simulator for kids.

Is it slow…Hobbes
experience
Bykov, Vassili: Cincom
Tuesday 2:00:00 pm to 2:30:00 pm

Abstract: Hobbes is a virtual machine for the original Smalltalk-80. The entire VM is implemented in Smalltalk, but with the execution speed and implementation simplicity in mind. This makes its architecture and the implementation experience very different from the well-known Blue Book interpreter. This presentation will explore these differences--the most striking of which is that Hobbes is faster than a straightforward Blue Book implementation in C, while implementing Hobbes took only four days. This is also a chance to see the Smalltalk image that started it all 20 years ago.

Bio: Vassili Bykov started using Smalltalk in 1992 while working on his thesis. In the years that followed he was involved, among other things, in the development of Bytesmiths Toolkit and TOPLink for Smalltalk, and was an object technology instructor with The Object People. Since joining Cincom in 2000 he has been working on improving the VisualWorks IDE, as the technical lead of the Visual Works Tools project.

SmartPVS: Core business in Smalltalk
experience
Disselkoen, Vincent: Swiss Mobiliar Insurances
Tuesday 8:30:00 am to 9:15:00 am

Abstract: Swiss Mobiliar, established 1826, is one of the larger Swiss insurance companies. Its extensive net of over 100 agencies provides the valued personal approach, which is the hallmark of the company.
Since 1996, the sales process for some 1000 sales persons and 1500 backoffice employees has been supported by the highly flexible online/offline VA Smalltalk application ELAN: a rich client, incorporating not only the rules governing the complex insurance structures, but also the means to intelligently provide decision making by the insurance expert.
The flexibility needed is provided by a rule based system, which is parameterised using dynamic methods fully conforming to the Smalltalk syntax, and by a highly generic database design, originally based on the IBM IAA architecture. The expressive power of the system lies in the user interface, which is largely generic and model driven, and is dynamically rebuilt in runtime following any change made by the user.
This concept has proven successful enough to merit the total rebuild of the central sales and policy administration systems, based on a Server Smalltalk version of the current sales system core.
The new SST server application SmartPVS will live in a server farm and serve around 2000 online users throughout the country, and will be directly responsible for the central databases on the OS/390 mainframe. Parts of the current COBOL systems under IMS transactions will be incorporated using MQ Series, where communication will be over dynamically generated XML. The core system, including the dynamic user interface model, will remain unchanged, though the physical user interface will be a VA Java version, connected over RMI.
Exactly the same client and SST server code will be distributed to the 1000 standalone offline clients, eliminating the need for parallel maintenance. This architecture will remain active until the available wireless connections are sufficient to ensure continuous online wireless communication from all clients to the central server farm.
This experience report will focus on our experiences in the following fields:

• rule system
• serialization, session management, transaction handling and connections
• model driven remote dynamic GUI
• XML communication
• VA-Smalltalk / VA-Java communication using RMI
• MQ connection to IMS on OS/390

HOP: Multidialect Object Persistency framework
presentation
Ferraris, Giorgio: Elevensoft
Wednesday 10:30:00 am to 12:00:00 pm

Abstract: HOP is a persistency framework for various smalltalk dialects (VW, VSE, Dolphin, VA) with a high level of functionality. The framework's development started in the early '90s, and now it's used in hundreds of applications at several customer sites. We are now releasing a free, non commercial version, so this presentation will be a tutorial on the framework's use.
The presentation, with the help of some PowerPoint slide, will demonstrate the use of HOP in the development of a small application, with the definition of classes and the corresponding relational infrastructure for the persistency of objects. To demonstrate the feature of the framework, a small business model based on an Order will be defined. To demonstrate the data base independence of the resulting structure, a MySql and a Dbase or SQLServer relational data base will be used for persistency.

Bio: Giorgio Ferraris is a chemical engineer totally devoted to software. After years of work as a software free-lance consultant he co-founded, 15 years ago, Eleven srl, a small (20 people) Italian firm developing turn-key software solutions.
He started using Smalltalk more than 15 year ago (Smalltalk/V). He began following the international community first using Compuserve and the Digitalk forum, then participating in Smalltalk and OO related user conferences, starting from the Digitalk one, to SmalltalkSolution and OOPSLA.
He has been involved on OO analysis, design and architecture definition for 10's of customers (from small to medium to large). He follows his company's internal projects like lead technical mentor.
He has held several tutorials on OO, Smalltalk, OO analysis and design for 100's of Italian people and has worked as a mentor and supervisor on several OO projects. He is currently working as a mentor on several OO projects in Italy (Smalltalk, Java and C#), and following a big customer on his evaluation of Smalltalk as his possible next development language of choice.

Successful WebSphere and Smalltalk Coexistence
experience
Fiene, Fred, Alpert, Izaak, and Mackie, Dean: OTPP
Monday 4:00:00 pm to 4:45:00 pm

Abstract: The Ontario Teachers' Pension Plan is a CA$66Billion fund serving over 300,000 members. Its web site http://members.otpp.com uses IBM WebSphere as a front end, Cincom VisualWorks Smalltalk as a middle tier, and IBM DB2/400 back end. This experience report discusses WebSphere/Smalltalk interoperability, Smalltalk business domain logic reuse, and distributed architecture at OTPP. We will discuss the rationale for architectural decisions and our experience with this open heterogeneous environment, and future directions with service-oriented architecture. The predecessor system was discussed here: http://oopsla.acm.org/oopsla2001/fp/tech/TuesAM.html

Bio: Fred, Izaak, and Dean work at Ontario Teachers' Pension Plan in Toronto Canada.

Performance Tuning in GemStone/S
tutorial
Green, Norm: Gemstone
Wednesday 2:00:00 pm to 5:30:00 pm

Abstract: Gemstone performance tuning tutorial.

Bio: Norm Green has been using Smalltalk since 1992 when he worked for IBM Canada Manufacturing (now Celestica Inc.) in Toronto. There he was a lead developer on the DACS project, a data collection and shop floor control system written in GemStone/S and VisualWorks. Green joined GemStone in 1996 as a Senior Consultant and has traveled the world helping GemStone customers with their projects. Currently he manages the Smalltalk Engineering team at GemStone. Green earned a degree in Electrical Engineering from the University of New Brunswick in 1989.

Fun with (VisualWorks) Fonts
presentation
Griggs, Travis: Key Technologies
Monday 8:30:00 am to 9:30:00 am

Overview: VisualWorks fonts are not the most understood of things. Many VW programmers pass up the opportunity to make their applications look nicer than they could, because they little understand the fonts. Recently, frustrated with merging font hacks for PDP, super/sub-script support, and the RB Code Highlighter, I implemented the ExtraEmphases framework. This presentation will cover why and how that was implemented, as well as how to use and extend it. Hopefully, along the way, we can provide a better understanding about how the basic font system works.

Bio: Travis works for Key Technology, figuring out how to sort the world's food (among other things). He's worked with Smalltalk (mostly, but not entirely VisualWorks) since 1991. His work in that domain ranges from embedded programming to high level user interface design. Before coming to Key Technology, he worked at Siemens Power Corp writing nuclear fuel design automation software in Smalltalk. When not hacking for Key, he does his best to contribute to various open source projects, some in Smalltalk, some not.

smallCharts - its development and design
experience
Haider, Christian: Smalltalked Visuals
Wednesday 2:45:00 pm to 3:30:00 pm

Abstract: smallCharts is a tool 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.

Bio: Christian Haider studied computer science and has worked in science, in the industry, as consultant and has recently founded his own company. He has used Smalltalk exclusively since 1994 for both personal and commercial programming.

Smalltalk in an Autonomous Underwater Vehicle
demo
Hylands, Jon: HUV
Wednesday 8:30:00 am to 10:00:00 am

Abstract: Autonomous underwater vehicles (AUVs) are an emerging technology that are ideally suited for exploring aquatic environments, in places where it may be too costly or dangerous for manned submersibles or remotely operated vehicles (ROVs) to operate. The software required to successfully pilot an AUV must be very robust, capable of complex behaviors, and also be easy to maintain and extend. Smalltalk fits the bill on all of these requirements. This demo will show MicroSeeker, a simple hobby-level autonomous underwater vehicle built by the presenter, with the high-level "brain" of the system running in Squeak Smalltalk on a PDA.

Bio:Jon Hylands has been doing Smalltalk programming since 1987. Jon's main interests include hobby robotics and autonomous submersibles, and making Smalltalk work on embedded devices.

STIC feedback/brainstorming session
special
Ignatow, Andrew et al.: STIC
Wednesday 4:00:00 pm to 5:30:00 pm

Abstract: Meet the board of STIC for a feedback and brainstorming session on how to promote Smalltalk. This is intended to give the community a chance to voice and document their ideas about how STIC and the Smalltalk vendors can do more from a marketing perspective to help grow the Smalltalk community, non-commercial and commercial.
Possible topics include:

O/R Mapping in Smalltalk
presentation
Knight, Alan: Cincom
Wednesday 2:00:00 pm to 3:30:00 pm

Abstract: Few areas arouse as many different opinions as storing objects in relational database. There are some fundamental issues in doing this efficiently. Also, we often don't have the luxury of designing our own schema, but have to deal with one that does not correspond well to our object model. This presentation outlines some of these problems and the way they are addressed in the open-source GLORP framework (http://www.glorp.org), as well as how we plan to move forward on database mapping software in future releases of VisualWorks.

Bio: Alan Knight is a senior developer with Cincom Systems, where he is involved with web application development and database mapping. Before joining Cincom he was with The Object People, where he served in a variety of roles, most recently chief architect for the TOPLink family of Object-Relational Mapping products, both Smalltalk and Java. He is a former member of the Sun JSR committees for JDO and EJB 2.0, co-author of the book Mastering ENVY/Developer, a former columnist for The Smalltalk Report, and a frequent speaker at a variety of conferences. He is also program chair of Smalltalk Solutions 2003.

Automotive Manufacturing Execution Systems In Smalltalk
experience report
Krock, Reg: Locksley Creek Software
Monday 4:45:00 pm to 5:30:00 pm

Abstract: This session would review the experience of implementing a distributed VAST solution in three automotive plants. The experience report would review the original design and how it improved from plant to plant.
Issues involved included guaranteed fast response time, robustness, agile systems using simplified rules and actions, and coordination of the entire system. The most recent system had a shop floor response time of approximately 20 milliseconds per event. It has met this and other requiements well, had a very smooth implementation, and is now a great success story.

Bio: Reg Krock has been involved in software development, in a variety of management and development roles, for the last 25 years. For the last 7 years he has been involved in the development of Smalltalk applications in the manufacturing environment, primarily real-time manufacturing execution systems for automotive plants. He has also been involved in the development of Smalltalk applications for the steel and automotive parts sectors.

Adding Strong Encryption to the MSN Instant Messenger Network
presentation
Lander, Anthony: independent consultant
Tuesday 9:15:00 am to 10:00:00 am

Abstract: This talk looks at the design and implementation of Pongo, an open source MSN Instant Messenger client written in VisualWorks Smalltalk. Pongo adds a strong encryption layer to MSN IM enabling users to have encrypted conversations over chat. This talk looks briefly at the MSN protocol, and the implementation of the Pongo client, but focuses primarily on understanding the design of the encryption layer. Participants should have an intermediate understanding of Smalltalk. No knowledge of encryption is required.

Bio: Anthony Lander has been programming in Smalltalk for over ten years. He has worked on a variety of projects developing database connectivity frameworks, communications switching software, law enforcement applications and real-time 3d video games.

Time To Market with Smalltalk Technology?
presentation
Lount, Peter: independent consultant
Monday 2:45:00 pm to 3:30:00 pm

Abstract: The simplicity, effectiveness and elegance of Smalltalk comes from it's simple yet highly expressive syntax and the design of it's various libraries of 'objects'. Smalltalk was the first, and remains one of the few, pure object systems, which simply means that everything in a Smalltalk program is an object. Smalltalk is generally recognized as the second Object Programming Language and the first true Integrated Development Environment (IDE). All of these have important benefits.
An object is a collection of data grouped together in meaningful ways with related operations, or chunks of programs, that manipulate that data. It is suprising how well this way of organizing software works. Objects get work done by sending 'messages' to each other. i.e. In english this would be like Jill saying to Jack, Jack drop the ball please. In Smalltalk this might be written as jack dropTheBall. Communication via messages is something that we're all familar with in our lives. Messages can be thought of as 'verbs' that ask the receiving object to perform an operation. Messages may have objects as parameters. i.e. In english this would be like someone saying to Jack, Jack pass the ball to Jill. In Smalltalk this might be written as jack passTheBallTo: jill or even more flexibly as jack pass: theBall to: jill so that other objects, like aPen, can be passed around. A nice example of accomplishing more with less.
Smalltalk has a powerful concept known as "blocks" which are snippets of program code that are also treated as objects, this enables them to be used like any other object. In addition blocks enable you to extend the Smalltalk language very easily in powerful ways that other popular languages only dream of.
Smalltalk was designed to be easy to learn and use. It is an expressive language that uses a simple sub set of human languages, nouns and verbs. Something that all humans can related to. This faciliates a clean expression of solutions that map very well with human thinking. This is one of the compelling reasons that Smalltalk programs tend to be one third to one half the size of programs written in other popular languages. Smalltalk programs typically can do two to three times as much work for the same amount of code. Often Smalltalk programs can actually do a lot more with much less code. Less code to write, re-write, test and maintain means a lower cost of development, a faster time to market, and potentially a higher quality of system which lowers maintenance costs again and opens new opportunities.
The bottom line is that Smalltalk can work for you by letting you focus on your solutions and the rewards of your business endeavours.

Bio: NA

JWARS performance tuning
presentation
MacQueen, Donald: JWARS
Tuesday 3:00:00 pm to 3:30:00 pm

Abstract: JWARS (the Joint Warfare System) is a simulation, written in Visual Age Smalltalk, that models theater level warfare. One of its primary requirements is that the model run 1000:1; that is, a 100 day campaign (2400 hours) must run in 2.4 hours.
This presentation will discuss how we improved JWARS runtime from 133:1 to over 1500:1 by using the profiler, experimenting with settings for old space, and taking care not to overtax the garbage collector.

Bio: Donald MacQueen has been a jWarrior since 1997. He recently added sonobuoy modelling to JWARS for the US Navy. His love affair with Smalltalk began in 1992 when he was toiling in the C++ salt mines, and it's been sunshine and blue skies ever since.

Introduction to Gemstone
tutorial
McClure, Martin: Gemstone
Tuesday 4:00:00 pm to 5:30:00 pm

Abstract: Introduction to GemStone/S starts with a quick overview of the concepts, organization, and applications of the GemStone/S object database and application server. Several topics chosen by the audience are then explored in more depth. The first section is suitable for Smalltalkers with no prior GemStone experience.

Bio: Martin McClure has been a software engineer at GemStone Systems since 1996, but his enthusiasm for Smalltalk dates back to the '70s. In 1985, he founded one of the earliest Smalltalk users groups. When he's not wrangling objects you can find him at a science fiction convention or blowing glass in the north woods.

AOStA An Adaptive Optimizing Smalltalk Architecture
presentation
Miranda, Eliot: Cincom
Tuesday 2:00:00 pm to 3:30:00 pm

Abstract: AOStA is a portable architecture for adaptive optimization in the context of existing Smalltalk virtual machines. The adaptive optimizer is a bytecode-to-bytecode optimizing and inlining compiler. It is written in Smalltalk, runs in the image, and in a meaningful way is portable across dialects. It runs above a JIT virtual machine with minimal extensions to allow introspection on in-line cache information, to provide simplified "go-faster" versions of certain primitives, and to callback into Smalltalk from "hot spots".

Bio: Eliot Miranda is technical lead for VisualWorks, the direct commercial descendent of Xerox Smalltalk-80, at Cincom Systems, Inc. Eliot has been working on Smalltalk VMs since 1983. Eliot got his degree in Computer Science at the University of York before becomming a research assistant and lecturer at the University of London. During this period he designed and implemented the BrouHaHa bytecode and threaded code VMs which achieved a good compromise of performance and portability through innovative C compiler abuse. After a brief digression collaborating on the Harlequin Dylan implementation, designing the stream and pickling systems he joined ParcPlace Systems in 1995. He designed VisualWorks' threaded interconnect, the programmer-productivity features of the parcel component system and significant performance improvements to the VM, all within the context of a merger, three name changes and a purchase by Cincom in 1999, and can say with some relief that the system is still commercially viable. Eliot has been a member of the ACM since 1988.

Opentalk Matrix and P2P, JxTA
presentation
Monteiro, Charles: independent consultant
Wednesday 8:30:00 am to 10:00:00 am

Abstract: The OpentalkMatrix is a runtime peer to peer framework based on VisualWork's OpentalkTalk distributed communications framework. The presentation will demonstrate:

• Component Sharing Services: file sharing services with specific support for VisualWorks's parcel files which provide functionality similar to the "Java Web Start"


• P2P Network Services akin to web services: OpentalkMatrix provides for a runtime P2P infrastructure where service modules in the form of parcel files can be registred at respective nodes. An inquiry mechanims allows for the finding of services and the eventual engaging of a particular service.

An open-source acceptance testing application
presentation
Morrison, Sean: OTPP
Tuesday 9:15:00 am to 10:00:00 am

Abstract: The development environment at OTPP includes a large number of non-technical business analysts who validate the correctness of applications developed in-house. These businesspeople use an internally developed testing application named BRITE to run acceptance level tests against our applications to validate new features and to guard against regression. Traditionally, BRITE was used to test applications written in Smalltalk. It has recently been extended to include the ability to test applications written in other languages and applications that run within a server environment (as opposed to on client PCs).
BRITE has seen a considerable amount of work put into it in the last year and the decision has been made to release the code under an open-source license so that others may benefit from it (and hopefully contribute to it's continued improvement). The first release of an open-source version of BRITE is imminent.
My intent is to present BRITE as an alternative to other, commercial, testing applications (e.g. SilverMark), and to discuss the structure and capabilities of the application for those who might be interested in integrating it into their work environment. I will also focus on those aspects of the application that I feel were enabled, or made much easier to implement, by the use of Smalltalk as an implementation language.

Bio: I've been working in Smalltalk and Java at the Ontario Teachers' Pension Plan (otpp.com) since graduating from the University of Ottawa in 1998. I'm a Smalltalk advocate active with the Toronto Smalltalk User's Group.

User group panel
panel
Nemec, Bob, et al.: Northwater Objects
Tuesday 2:00:00 pm to 3:30:00 pm

Abstract: Local Smalltalk user groups are one of the most valuable community resources. How do you start a group, keep it going, keep it interesting. This will be a panel discussion featuring members from a variety of user groups.

Bio: Bob Nemec (moderator) is chair of the Toronto Smalltalk User Group.

Black Knight: Eclipse as a Smalltalk Development Environment
presentation
O'Keefe, John and Clayberg, Eric: IBM
Monday 2:00:00 pm to 3:30:00 pm

Abstract: Smalltalk is arguably the world's most productive programming language. Eclipse is quickly approaching being the world's best development framework -- "an open extensible IDE for anything and nothing in particular". Black Knight represents the marriage of these two premier technologies. It provides a set of Smalltalk Development Tools that bring the best features of existing Smalltalk IDE's into the Eclipse world, an extensible Smalltalk class library based on the VisualAge Smalltalk Enterprise code, and an executable runtime for applications developed in Smalltalk. Black Knight is an Eclipse Technology Subproject.

Bio: John O'Keefe has been doing software development since it was done with wires and patch-panels. He has been on the VisualAge Smalltalk team since 1992 and has been the Team Lead for the last 7 years. Most recently he has formed the Black Knight team to produce a new cross-dialect Smalltalk IDE.

Unit Testing web applications
presentation
Putney, Colin: Whistler.com
Wednesday 2:00:00 pm to 2:45:00 pm

Abstract: The talk describes the templating system we've been using at Whistler.com and the testing methodology we use with it. The templating system follows an MVC pattern where templates are parsed into a DOM-like tree of views, which are manipulated by the component using LISP-like macros. The first part of the talk describes the framework and explore the motivations behind its design. The second part describes the requirements for testing web-based UIs, how this template system has allowed us to write testable UIs and the test patterns we've found effective.

Microlingua, a Tiny Real-Time Smalltalk
presentation
Rabb, Maurice: Stono Technologies LLC
Monday 4:00:00 pm to 5:30:00 pm

Abstract: Dynamic object-oriented programming languages are rarely used in small or real-time embedded systems. This presentation will discuss implementation techniques originally developed to enable Smalltalk to run efficiently on tiny consumer electronic products such as animated watches. The work has application in other domains including wireless, medical, industrial, and military equipment.
Topics will include developments since Smalltalk Solutions 2002, as well as issues around real-time garbage collection, scaleable object models, fast ROMable message dispatch and resolution, fast and consistent numerics, handling immutability, and consistent and easy concurrency.
One of the speaker's goals is to enable Smalltalk to run on new cellphones. Wireless handsets represent a new frontier in computing, and possibly an enormous new marketplace for Smalltalk.

Bio: Maurice Rabb is the Director of Special Projects at Blackwell Consulting Services in Chicago. He specializes in new product development, design patterns, object mentoring, and conceptual blockbusting. Mr. Rabb is co-founder of Stono Technologies LLC, a firm dedicated to the development of new technologies for the consumer electronics industry. Mr. Rabb is a Squeaker, and earned his BS and MS in engineering from Stanford University.

The Multi-Process UI in VW 7.1
presentation
Raymond, Terry: Crafted Smalltalk
Monday 2:00:00 pm to 2:45:00 pm

Abstract: I will be discussing; the reasons for modifying VisualWorks to use multiple user interface processes instead of a single process, the design concepts embodied in the MPUI changes, and what the changes mean for various types of applications.

Bio: Terry Raymond is the author of the Smalltalk Professional Debug Package. He spent four years working on the development of a Manufacturing Execution System which encompases, managing a manufacturing plant model, scheduling tasks, executing the tasks in real time, and user interfaces that monitor the tasks. He has over 13 years experience with Smalltalk, going back to ObjectWorks Smalltalk 2.5 and several years experience in the development of real-time systems.

Clean-Slate Smalltalk
presentation
Rice, Brian: LOGOS Research and Development
Wednesday 4:00:00 pm to 5:30:00 pm

Abstract: We have applied some very simple but powerful and coherent concepts to enhance the Smalltalk family of languages. We have also taken the time to build up this new Smalltalk from scratch, with new innovative thinking in run-time architectures and systematic library use of the new semantics. This combination provides a very powerful and flexible environment that can be worth the migration to a somewhat new language.
For more information, see http://slate.tunes.org/

Bio: Brian Rice is a long-time member and contributor to the open-source Smalltalk and Lisp communities, focussing on web, computer graphics, networking, and database applications. He has been conducting informal research into language and system design for several years, and recently started a private company in Seattle called LOGOS R&D to channel these activities into a venture to develop high-level dynamic products and platforms.
His current major project is "Clean Slate" Smalltalk, a re-thinking of many Smalltalk traditions designed to support a more powerful and flexible platform for development, along with a graphics interface architecture that takes the best ideas from the last two decades in design and molds them into a coherent and powerful framework. Slate's design is based on experience with several Smalltalk systems and observing their evolution.

The Mysteries of the RB Rewrite Tool (aka roll-your-own ""refactorings"")
tutorial
Roberts, Don, Brant, John: Refactory
Monday 2:00:00 pm to 5:30:00 pm

Abstract: At the heart of the Refactoring Browser is a general transformation tool known as the "Rewrite Tool" all of the refactorings use this tool to transform the actual smalltalk code. It is possible to use this tool to create your own custom transformations. These transformation might be refactorings but can also be used for any task requiring changing a lot of code. It has been used for migrating between dialects of Smalltalk, replacing a data-access layer with a different one, and converting an application to use ANSI standard exceptions.
Participants will learn the syntax of the rewrite tool along with the concepts necessary to create their own rules. This tutorial will consist of many examples of the various types of rules.

Bio: John Brant and Don Roberts are the co-creators of the Refactoring Browser, the first commercially viable refactoring tool for any language. They are consultants and have spent the past several years working on various projects in addition to developing the RB. Don has recently gone legit and is an assistant professor at the University of Evansville.

WebLog and associated tools
presentation
Robertson, James: Cincom
Wednesday 2:45:00 pm to 3:30:00 pm

Abstract: James Robertson, Product Manager for Cincom Smalltalk, will talk about Blogs, RSS, and news aggregators. Over the last two years, blogs have exploded as a new communications mechanism. While most of the well known ones are political in nature (cf InstaPundit - http://www.instapundit.com) - there are a large number of blogs oriented towards a wide variety of topics. The Groove project has a blog devoted to the progress of that project - http://www.ozzie.net/blog/. This is an area that should be of interest to project managers - blogs are an excellent way to spread information on your project - both publically and internally.
Over the course of the last year, I've run a blog - http://www.cincomsmalltalk.com/blog/blogView, devoted to discussing IT industry trends, with an eye on Smalltalk. I'll discuss the technical issues involved in implementing the blog, and the connections that have flowed out of it via RSS and news aggregation. This will involve some discussion of BottomFeeder - http://www.cincomsmalltalk.com/BottomFeeder - an open source RSS News aggregator.

A new MacOS X Smalltalk
presentation
Sandu, Dorin and Suska, Mark: Carleton University
Wednesday 10:30:00 am to 11:15:00 am

Abstract: We will introduce a brand new Smalltalk system that runs natively under MacOS X. After a tour of the development environment, we will cover the design and implementation of the user interface framework including the native interface to the OS. Time permitting, we will review VM design issues and discuss future development plans.

Bio: Dorin Sandu teaches Computer Science at Carleton University and Mark Suska develops embedded software for Symagery Microsystems, Inc. Both Dorin and Mark have used Smalltalk since 1990.

An Application Framework for Developing MVC web applications with the VisualWorks WebToolkit
tutorial
Shaffer, C. David: Westminster College
Tuesday 2:00:00 pm to 5:30:00 pm

Abstract: Keep your code off of my page. Developing server-side web applications using technologies like Smalltalk Server Pages and Java Server Pages can lead to applications which are difficult to extend or maintain. This is especially true when such pages need to be maintained by both web page designers and programmers. This tutorial will present a framework for developing MVC-style applications using Smalltalk Server Pages, Custom Tag Libraries and Servlets. Use of this framework can result in well-factored applications having clear boundaries between the presentation layer and the underlying business/persistence/transaction layers.

Separation of the presentation layer when developing server-side web applications is achieved by combining Servlets, Smalltalk Server Pages, form models, and Command objects, in a manner similar to that used in the Java-based Jakarta Struts project[1]. This model is similar in purpose to the framework discussed by Knight and Dai in ``Objects and the Web''[2] and consists of three related components:

• An extensive custom tag library
  • for more self-describing page markup,
  • to simplify input validation,
  • to provide scripting capabilities to web page designers (without resorting to Smalltalk) ,
  • to help communicate between the presentation and control layers,

• A centralized Servlet which controls flow, provides final validation of data and invokes ``Command'' objects,

• Command objects typically implementing use-cases in your application.

In this tutorial each of these components will be presented and utilized in the context of developing a web application. The resulting application demonstrates most of the common forms of web interaction. The full source of the supporting framework and sample application will be provided to attendees for their extension and/or incorporation in their own applications.

Attendee Background: This tutorial is geared toward Smalltalk developers with little or no web development experience. Some VisualWorks experience will be helpful but not required.

Bio: David Shaffer has worked designing Object-Oriented web applications for the Electro-Plating industry since 1997. He is also an assistant professor of Computer Science at Westminster College where he uses Smalltalk extensively in his courses.

Advanced Pollock: Under The Hood, Getting Your Hands Dirty
presentation
Shuster, Samuel: Cincom
Tuesday 4:00:00 pm to 5:30:00 pm

Abstract: Often the best way to really understand a framework is to try to use or extend it in some way. With that in mind, in this presentation we will extend the Pollock Framework by adding a new widget. Using Unit Tests and "Gang" programming, we will take a ride on the Pollock bus.
By building this new widget, we will see how and where and when a Pane interacts with its Agent and its Artist. We will also see the new reduced role of the Controller, and its new abstract API. With this information, people who have extended or added widgets in the current VisualWorks GUI framework, will be able take that knowledge and apply it to Pollock.
Ample time will be given to discuss the existing Pollock framework, and its future, as well as how to improve the framework.

Bio: Samuel S. Shuster is the GUI project lead for VisualWorks Smalltalk. An early Windows programmer, he has been, sometimes reluctantly, exposed to many GUI development frameworks and tools in multiple programming languages, including experience with all commercial Smalltalk GUI frameworks. Taking these as a guide, along with many GUI framework research projects, he has taken the best from each and synthesized them into a new GUI framework for VisualWorks: Pollock. Unfortunately, he had no idea what he was really getting into.

Preparing For Pollock - The Future of the VisualWorks GUI
tutorial
Shuster, Samuel: Cincom
Wednesday 8:30:00 am to 12:00:00 pm

Abstract: This will be a lively presentation of the new and evolving GUI framework for VisualWorks. We will present the philosophy and goals of the new framework, tools that the new framework will provide, as well as instructions on how to prepare existing VisualWorks applications for Pollock.
We will also present the Trigger Event system, and how the existing "Model" hierarchy is affected by this system. Since the new GUI Framework uses this system extensively, and VisualWorks 7 has full support for this system, we will present how existing code can be made easy to adapt to Pollock. We will also present the new "Multi-Process" GUI framework, introduced in VisualWorks 7.1, and the effects it will have on existing add on widgets. We will present the new Drag-Drop framework, and discuss how it interacts with the Trigger Event system.
As part of the presentation, we will present and discuss Pollock conversion tools, as well as how to create code with the current frameworks that will ease the transition to Pollock.
Finally, we will open the floor to discuss the Pollock framework and any community concerns and suggestions.

Bio: Samuel S. Shuster is the GUI project lead for VisualWorks Smalltalk. An early Windows programmer, he has been, sometimes reluctantly, exposed to many GUI development frameworks and tools in multiple programming languages, including experience with all commercial Smalltalk GUI frameworks. Taking these as a guide, along with many GUI framework research projects, he has taken the best from each and synthesized them into a new GUI framework for VisualWorks: Pollock. Unfortunately, he had no idea what he was really getting into.

Delivering Smalltalk natively on .NET with S#.NET and S#.AOS — Competing on a level playing field
tutorial
Simmons, David: Smallscript
Tuesday 2:00:00 pm to 5:30:00 pm

Abstract: This tutorial will present the working S#.NET and S#.AOS system toolset and language. Attendees will learn how to write secure, verifiable applications, components, and frameworks in Smalltalk that deploy natively on .NET.
Special focus will be given to both business and technical aspects of creating libraries in Smalltalk that can be consumed and/or sold for standard use and consumption by any other .NET language. If you want options for being able to write code in Smalltalk while conforming to mainstream demands for .NET interop compliance and compatibility with languages like C# and VB then this tutorial is for you.
S# is a modular superset of the Smalltalk-98 language offering a rich, generalized, object model for dynamic languages on both its own native SmallScript AOS platform and the Microsoft .NET Platforms.

Bio: David Simmons has been designing and developing language systems and virtual machines for since the early 1980's. He was the principal designer and architect for commercial toolset within QKS Smalltalk-91 and its multi-language, multi-threaded execution engine. His most recent work has been the design and development of S# within the SmallScript Language System, a modular multi-threaded platform for dynamic languages. His design work has focused heavily on complexity management, portability, modularity, performance, object models, and meta-object protocol capabilities for supporting a superset of today's popular programming language features.

Croquet - A Collaboration Architecture
keynote
Smith, David: OpenCroquet
Tuesday 10:30:00 am to 12:00:00 pm

Open Session on Gemstone Solutions
workshop
Smith, Dennis: Cherniak Software
Monday 4:00:00 pm to 5:30:00 pm

Abstract: This session will open with a short (20min) presentation on two Gemstone solutions: obtaining a controlled unique number for business use, such as P/O #; forwarder enhancements using subclasses for enhanced traces and handling of ^self for uncached-forwarders. The remainder of the session will be devoted to discussion of gemstone developer problems and solutions. After a brief introduction of attendees, questions from the floor will be discussed among attendees, many of whom will have had a number of years experience with gemstone. Questions at any level above "how do I use gemstone" are reasonable. This session should be a great learning experience for developers at every level, and is patterned on a session held at SS 2001.

SmallCOM/X
demo
Springer, Josef: JOOPS
Monday 2:45:00 pm to 3:30:00 pm

Abstract: SmallCOM/X is a Win32-Tool, which generates VisualWorks-Smalltalk classes for ActiveX (OCX) components from COM type libraries.
SmallCOM/X generates in addition to SmallCOM the classes and code to handle the component as a normal widget and to use this widget in the UIPainter:

The nature of certain enterprise systems
experience report
van Echtelt, Mathieu: CosmoCows
Monday 2:00:00 pm to 2:45:00 pm

Abstract: Exploration of patterns and ideas to model and implement inter-corporation business processes.

Highlighted case: In partnership with EDS, CosmoCows has developed and implemented a system for integration of passenger transportation businesses. The system was developed for a key player in the Dutch passengers transport market. It integrates planning, purchase and sales of participating transportation providers in order to enhance customer transportation service and increase efficiency. A web interface fully supports all interactions between the participating transportation providers and their customers.
Highlighted design issues: Contracts, transactions, validation and persistency.
Main technologies used: VisualWorks/Smalltalk, Java, C, CORBA, Oracle.

Bio: Mathieu has 8 years of experience in development and project management in the software industry for clients across several industries.

Squeak Update
presentation
Way, Doug:
Tuesday 4:00:00 pm to 5:00:00 pm

An update on happenings in the world of Squeak.

Using Smartcards for logging into Gemstone Databases
presentation
Wullschleger, Alfred: Swiss National Bank
Wednesday 4:00:00 pm to 5:30:00 pm

Abstract: 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:
We install a so-called LogonServer LS, a headless VisualWorks-Image on the database computer, where GS is running. LS has a direct connection (not going over the network) through an account 'OTPUser' with GS. The account 'OTPUser' is privileged, so that it can set passwords for users. Each time a user wants to login into the database, his client-image requests a One-Time-Password (OTP) from the LS. When the user has a valid account in GS and there is a corresponding RSA-Public-Key found on GS, LS will send the newly created OTP encryted by the RSA-public key to the user and set the OTP on GS. The user can then decrypt the OTP by using his Smartcard and use OTP to directly login in the usual way into GS. As soon as he is logged in, the OTP is no longer valid (expirationcount = 1), so the OTP can be sent unencrypted over the network. When the user cannot decrypt the OTP, he can not login, so the LS has no problems with invalid requests. For the OTP we currently use a 20-byte random value, encoded as 49-digit decimal number.
When the user has forgotten his Smartcard at home, we use a credentials record in Gemstone, by which the user can be authenticated. He enters a password, that is transmitted to the logon server (LS) together with his username. The LS decrypts the credentials record, if ok, the user gets back an OTP with which he can login into Gemstone. All communications are encrcypted with Blowfish using Diffie-Hellman session key generation. The LS authenticates itself by an RSA-signature for its Diffie-Hellman "halfkey".
For batch users, we are planning a ticket with a time validity slot. Only a "real" person, that is logged into GS can get the ticket, but the batch process will present the ticket when it wants to login into GS to the LS. The batch process is responsible for the secure storage of the ticket until it will use it. Presenting a valid ticket to LS will allow to create a OTP on GS, that the batch process can then use.
The talk explains the ideas and presents the details about the implementation in VisualWorks and Gemstone/S.

Bio: A. Wullschleger has been programming Smalltalk during the last eleven years. Since four years, he works for the Swiss Nationalbank, the central bank of Switzerland. He leads the OASE project which is a statistics database implemented in Gemstone and using VisualWorks Clients on Windows (verifyably running also on Linux).