Chapter 1 - Smalltalk History and Concepts
A brief history of Smalltalk is presented, from origin to commercialization, to the present day. Some of the key concepts of Smalltalk are summarized here.
Chapter 2 - Style
This chapter covers many of the elements that contribute to a quality Smalltalk program. Topics include method style, class inheritance, system class changes, dynamic messaging, and documentation.
Chapter 3 - Dependencies
The dependency mechanism allows one object to be notified when another object changes. This topic is covered with a description of how it works, how to use it, why to use it, and a reference to its use.
Chapter 4 - Processes and Threads
A brief overview of the concepts of processes and threads and how they apply to parallel processing in Smalltalk is presented, followed by synchronization concepts, examples, and a reference to the thread related classes.
Chapter 5 - Exceptions
An exception handling system is provided in Smalltalk. This allows programs to handle exceptional events or data without producing an error or crashing. An overview of the concepts is presented, followed by in-depth analysis of each of the Smalltalk mechanisms, how to do it, and a reference.
Chapter 6 - Methodology and Project Management
These days everyone is selling a methodology. They are all slightly different, take a long time to learn, and may not help you to be more productive immediately. A simple, get-it-done (GID) methodology is presented here, with references and comparisons to the approach of using a standard methodology. The entire project life-cycle is discussed, with an emphasis throughout the chapter on the engineering of a system from "cradle to grave".
Chapter 7 - Methodology Applied: A Personal Information Manager (PIM)
An end to end example of designing and building an application in Smalltalk is presented here in brief form. A Personal Information Manager(PIM) is the target program and the steps to deliver the application are discussed. The code for the PIM is also presented.
Chapter 8 - Frameworks
Just what is a Framework? And how is it different from a Pattern? These questions and a few resources for learning more are presented here.
Chapter 9 - Patterns
What is a Pattern? How do I write one? Where can I find more? And where can I learn more? These questions are answered here.
Chapter 10 - Smalltalk Bugs
Some of the biggest gotchas of Smalltalk programming are presented here, with some tips on avoiding them.
Chapter 11 - Development Tricks
Here is a compilation of the most useful pieces of Smalltalk trickery that I have accumulated. It covers items like bookmarks, safe halting and printing.
Chapter 12 - Message Frequency
Ever wonder which methods are written the most when writing Smalltalk code? A statistics gathering program is written for five versions of Smalltalk, and the programs and the results are presented here.
Chapter 13 - The Most Useful Methods
These are the most useful methods that could be gleaned from the vast set of hundreds of classes and thousands of methods. This is the short version and cheat sheet for the class encyclopedia. See how many you use regularly, and those that you may have missed.
Chapter 14 - Teamwork
Nothing is more challenging that organizing a group of people to accomplish one task. Sometimes it is easier to part oceans or make the earth move, but here are some tips on how to work together using Smalltalk as the development language. Low-budget techniques are discussed, as well as the use of two of the leading team development tools: Team/V and ENVY.
Chapter 15 - Profiling/Tuning
Ever wonder why you agree with non-Smalltalker when they say Smalltalk is slow? Now you won't have to hide your face in shame once your programs have been souped up with some tuning tips. The steps necessary to identify program bottlenecks, with solutions to many problems are presented here. Many good techniques write faster code the first time around are also presented.
Chapter 16- Application Delivery
One of the most puzzling concepts to new Smalltalk programmers is how to deliver a program once it is written. Many people are familiar with a 'compile-link-deliver' cycle, so the switch to a 'Customize the running application' approach is uncertain. Issues and techniques to deliver your Smalltalk application to your customers are discussed, along with the process to do so in each of the Smalltalk versions.
Chapter 17- Primitives and External Code
It is nearly impossible to deliver a fully functional Smalltalk application without writing code outside the Smalltalk environment. Whether it is C or Assembly primitives or COBOL external code, integrating non-Smalltalk legacy code with your Smalltalk application is a common challenge with many pitfalls. Examples are provided for each version of Smalltalk for both Primitives and External Code calls, with a template file so that you can create your own code right away.
Chapter 18- SQL Databases
The majority of enterprise information is stored in databases, whether they be flat files, hierarchical databases, or SQL databases, you need to be able to access this information in Smalltalk. Some of the approaches to storage and retrieval of database information are discussed, with relevant issues and a survey of available options. Also covered are data migration strategy, data security issues, and examples of accessing SQL databases from Smalltalk.
Chapter 19- External Storage and Persistent Objects
What happens when you need to store and retrieve data, but don't need to keep a legacy database (or can migrate the data ), or have a new application that will be totally object oriented? You can't expect each user to have a development license and save the image in order to store objects, so you make the objects persistent. Persistent objects are usually binary files or databases that keep objects alive when the application is not running. They take the form of source code that recreates binary objects, file based object storage (ObjectFiler, BOSS, PIPO), or object databases like Tensegrity, Gemstone, Versant, etc. This chapter covers the strategies, products, and examples of how to effectively make your objects persistent.
Chapter 20- Internet and Web Applications
With all the hype and the ensuing product frenzy, Smalltalk is fast becoming a solution for complex Internet/Web based applications. Transmission Control Protocol/Internet Protocol (TCP/IP) is the network set of protocols for communications and is essential to working on the Internet. This chapter includes an overview of resources, the TCP/IP protocol, HyperText Transfer Protocol (HTTP), HyperText Markup Language (HTML), and examples of communications code, including sockets, and an Internet Web server that will allow you to create Web aware applications today.
Chapter 21- Neural Networks
The notion of an artificial brain is very appealing. Neural networks are a step in this direction in that they 'learn' the appropriate response to a stimulus through training, and then respond the same and similar stimuli with the learned response. You will learn about neural networks, their uses, and the application of neural networks to Smalltalk applications. A functioning neural network program is included, and the details of its functionality are discussed
Appendix A- Smalltalk Resources
Who, What, Where, including: Books, Software, Training, and User Groups
Appendix B- Smalltalk Interview Questions
How do you qualify the Smalltalk developers on your project, especially when you are new to Smalltalk? Here is a set of questions designed to promote an exchange of information relevant to Smalltalk development.
Appendix C- Class Hierarchy Comparisons
A class hierarchy listing for each of the major versions of Smalltalk serves as a quick reference when programming in the language.
Appendix D- ANSI Smalltalk Standard
The latest information for the Smalltalk ANSI Standard is included here for your reference.
Appendix E- On the CD-ROM
A listing of the contents of the CD and how to get started with it.