The World of Smalltalk

From Philosophy to Practice A Complete Guide to the Language That Invented Object-Oriented Programming

1. About This Book

Introduction

1. What You Will Learn
2. Who This Book Is For
3. How to Read This Book
4. A Note on Implementations
5. Why This Matters Now

Chapter 1: The Birth of a Revolution

1. The Xerox PARC Years (1970–1980)
2. Alan Kay’s Vision: Objects as Living Things
3. Smalltalk-72, -74 and -80: A Brief Evolution
4. The Influence on Modern Computing
5. Why Learn Smalltalk Today?

Chapter 2: Your First Steps in Smalltalk

1. Choosing an Implementation (Pharo, Squeak, GNU Smalltalk)
2. Installing and Launching Your Environment
3. The Smalltalk Desktop: Overview of Tools
4. The Workspace: Your Interactive Playground
5. Image-Based Development vs File-Based Development
6. Running Your First Code: Hello World and Beyond

Chapter 3: Everything Is an Object

1. Objects, Classes and Instances Explained
2. Message Passing as Computation
3. The Hierarchy: Object at the Root
4. Literals Are Objects Too (Numbers, Strings, Characters)
5. Nil, True, False: Special Objects with Power

Chapter 4: Syntax and Expressions

1. Variables: Temporal, Instance, Class and Global
2. Assignment and Binding Semantics
3. Expression Evaluation Rules
4. Comments and Documentation Conventions
5. Whitespace, Line Breaks and Readability
6. Common Syntax Mistakes and How to Avoid Them

Chapter 5: Messages The Heart of Smalltalk

1. Unary Messages: No Arguments
2. Binary Messages: Operators as Messages
3. Keyword Messages: Named Arguments
4. Message Cascades: Fluent Style
5. Precedence and Evaluation Order
6. Undeliverable Messages and Error Handling Basics

Chapter 6: Classes, Methods and Encapsulation

1. Defining a Class: Syntax and Structure
2. Instance Variables and Accessors (Getters/Setters)
3. Methods: Defining Behavior
4. Self and Super: Identity and Delegation
5. Class Methods vs Instance Methods
6. Encapsulation Without Access Modifiers

Chapter 7: Inheritance and Polymorphism

1. The Inheritance Hierarchy in Detail
2. Method Lookup and Dispatch
3. Overriding and Extending Behavior
4. Polymorphism: Sending Messages Without Knowing Types
5. Abstract Classes and Interfaces (Protocols)
6. Composition vs Inheritance in Smalltalk

Chapter 8: Blocks and Closures

1. Block Syntax and Literals
2. Blocks as First-Class Objects
3. Lexical Scoping and Closure Semantics
4. Return Behavior: Block Return vs Method Return
5. Blocks in Control Structures (ifTrue:, whileTrue:)
6. Practical Patterns with Blocks

Chapter 9: Collections and Iteration

1. The Collection Hierarchy Overview
2. OrderedCollections and Arrays
3. Sets and Bags
4. Dictionaries and IdentityDictionaries
5. Iteration with Blocks (do:, select:, reject:, inject:)

Chapter 10: Control Flow, Exceptions and Robustness

1. Conditional Execution (ifTrue:, ifFalse:, ifTrue:ifFalse:)
2. Loops Without Keywords (whileTrue:, to:do:)
3. Exception Handling Framework
4. Resuming vs Returning from Exceptions
5. Assertions and Invariants
6. Defensive Programming Patterns

Chapter 11: The Smalltalk Environment in Depth

1. The System Browser: Navigating Code
2. The Inspector: Examining Live Objects
3. The Debugger: Interactive Error Recovery
4. The Workspace and Transcript
5. Refactoring Tools and Live Modification
6. Why This Matters: The Smalltalk Way of Working

Chapter 12: Reflection, Metaprogramming and the Object Model

1. The Object Model: Classes Are Objects Too
2. Metaclasses Explained
3. Method Dictionaries and Lookup Chains
4. Runtime Introspection (species, class, respondsTo:)
5. Dynamic Code Modification (compile:, removeSelector:)
6. Build Your Own Domain-Specific Languages

Chapter 13: Testing and Quality Assurance

1. The Built-In Testing Framework (TestCase, assert:)
2. Writing Your First Tests
3. Test Organization and Naming Conventions
4. Mocking and Stubbing Techniques
5. Continuous Integration with Smalltalk
6. Refactoring Safely with Tests

Chapter 14: Persistence and Storage

1. Image-Based Persistence: The Default Approach
2. Object Serialization (FileStream, BinaryOrTextStream)
3. Database Integration with SQL
4. Glorp: An ORM for Smalltalk
5. Designing for Persistence from the Start

Chapter 15: Concurrency and Parallelism

1. Processes and Scheduling
2. Creating and Managing Threads
3. Synchronization: Semaphores, Mutexes, CriticalSections
4. Shared State and Thread Safety
5. Message Passing for Concurrency
6. Performance Considerations in Concurrent Code

Chapter 16: Performance, Optimization and the Virtual Machine

1. The Smalltalk Virtual Machine Architecture
2. Compilation Model: Source to Bytecode
3. Garbage Collection Strategies
4. Primitives and Native Code Interfacing
5. Foreign Function Interface (FFI)
6. Profiling and Performance Tuning

Chapter 17: Application Architecture and Design Patterns

1. Packages and Code Organization
2. Model-View-Controller in Smalltalk
3. Dependency Management and Monticello
4. Design Patterns in Smalltalk Style
5. Building Reusable Frameworks
6. Large-Scale Application Architecture

Chapter 18: Deployment, Ecosystem and the Future

1. Deploying Smalltalk Applications
2. Web Development (Seaside, Zinc)
3. Headless and Server-Side Smalltalk
4. The Modern Ecosystem Landscape
5. Learning Resources and Community
6. Smalltalk’s Enduring Legacy

Conclusion: The Smalltalk Mindset

References