Smalltalk Programming: A Comprehensive Guide with Examples for Beginners

Last updated on July 4th, 2023

Introduction

Smalltalk Programming is an object-oriented programming language known for its simplicity, elegance, and live coding environment. Created in the 1970s at Xerox PARC, Smalltalk has had a significant impact on modern software development and remains relevant today. In this article, we will explore the fundamentals of Smalltalk programming and provide practical examples to help you understand its core concepts.

Understanding Smalltalk

Smalltalk programming follows a pure object-oriented paradigm where everything is an object. This means that even simple entities like numbers and characters are treated as objects with their own methods and properties. Smalltalk programming also supports dynamic typing, meaning you can change the class of an object during runtime.

Smalltalk Syntax

Smalltalk’s syntax is minimalistic and easy to read. Statements in Smalltalk consist of messages sent to objects, which are enclosed within parentheses. Here’s an example:

3 + 4.

In this example, the + message is sent to the object 3 with 4 as the parameter. Smalltalk programming uses periods to separate statements.

Creating Objects and Variables

In Smalltalk, objects are created using the new keyword. Variables in Smalltalk are not explicitly declared; instead, they are dynamically created and bound to objects using the := operator. Here’s an example:

| myObject |
myObject := MyClass new.
myObject doSomething.

In this example, we create a new instance of the MyClass object and assign it to the variable myObject. We then send the doSomething message to myObject.

Class Definition and Methods

In Smalltalk, classes are defined using the class keyword. Each class consists of instance variables and methods. Here’s an example of a simple class definition:

Object subclass: MyClass [
    | myVariable |
    
    initialize [
        myVariable := 0.
    ]
    
    doSomething [
        Transcript show: 'Hello, World!'.
    ]
]

In this example, we define a class named MyClass that subclasses Object. It has an instance variable myVariable and two methods: initialize and doSomething. The initialize method sets myVariable to 0, and the doSomething method displays “Hello, World!” in the Transcript.

Inheritance and Polymorphism

Smalltalk programming supports inheritance, allowing you to create new classes based on existing ones. You can also override or extend methods inherited from the superclass. Polymorphism is a key feature of Smalltalk, enabling objects of different classes to respond to the same message. Here’s an example:

Object subclass: Shape [
    area [
        "Abstract method to be overridden in subclasses"
    ]
]

Shape subclass: Rectangle [
    | width height |
    
    initialize: w height: h [
        width := w.
        height := h.
    ]
    
    area [
        ^ width * height.
    ]
]

Shape subclass: Circle [
    | radius |
    
    initialize: r [
        radius := r.
    ]
    
    area [
        ^ 3.14 * radius * radius.
    ]
]

In this example, we define a base class Shape with an abstract method area. We then create two subclasses, Rectangle and Circle, which override the area method to provide their specific implementations.

Key Features of Smalltalk

Smalltalk, as a programming language, boasts several key features that set it apart from other languages. Here are some of its notable features:

1. Object-Oriented Paradigm: Smalltalk is a purely object-oriented language. It treats everything as an object, including classes, methods, and even basic data types. This paradigm promotes encapsulation, modularity, and code reuse, making Smalltalk programs highly organized and maintainable.
2. Dynamic Typing: Smalltalk employs dynamic typing, meaning that variable types are determined during runtime rather than compile-time. This flexibility allows for easy modification of object behavior and encourages agile development practices.
3. Message Passing: Communication between objects in Smalltalk is achieved through message passing. Objects send messages to each other to request behavior or exchange information. This style of interaction promotes loose coupling and modular design.
4. Reflection and Introspection: Smalltalk provides powerful reflection and introspection capabilities, allowing objects to examine and modify their own structure and behavior at runtime. This feature enables advanced metaprogramming techniques and facilitates the development of sophisticated development tools.
5. Live Programming: Smalltalk pioneered the concept of live programming, where developers can modify and update code while a program is running without the need for a separate compilation step. This live coding environment encourages an iterative and interactive development process, enabling rapid prototyping and experimentation.
6. Image-based Development: Smalltalk uses an image-based development model, where the entire application state is saved as an image file. This image contains the code, objects, and their state, allowing developers to persistently store and restore the entire system state effortlessly. It supports seamless development and debugging sessions.
7. Extensive Development Environment: Smalltalk provides a comprehensive and integrated development environment (IDE) that includes tools for editing, debugging, and browsing code. The environment fosters a smooth development workflow by offering features like code completion, refactoring, and comprehensive documentation.
8. Garbage Collection: Smalltalk incorporates automatic memory management through garbage collection. It relieves developers from explicitly managing memory allocation and deallocation, resulting in safer and more efficient code.
9. Cross-Platform Compatibility: Smalltalk implementations are available for various operating systems, including Windows, macOS, and Linux, ensuring cross-platform compatibility. This feature allows Smalltalk developers to write code that can run seamlessly on different environments.
10. Large Collection of Libraries and Frameworks: Over the years, Smalltalk has accumulated a vast collection of libraries and frameworks, covering a wide range of domains such as GUI development, networking, databases, and more. These libraries enhance productivity and provide developers with ready-to-use components.

The combination of these features makes Smalltalk a unique and powerful language for building robust, flexible, and maintainable software systems. Its elegant syntax and focus on object-oriented design principles have influenced many other languages in the software development landscape.

An example in Smalltalk that demonstrates creating a simple banking application:

Object subclass: #BankAccount
    instanceVariableNames: 'owner balance'
    classVariableNames: ''
    poolDictionaries: ''
    category: 'Banking'

BankAccount>>initialize
    balance := 0.

BankAccount>>deposit: amount
    balance := balance + amount.

BankAccount>>withdraw: amount
    balance := balance - amount.

BankAccount>>displayBalance
    Transcript show: 'Current balance: ', balance asString; cr.

| account |
account := BankAccount new.
account initialize.
account deposit: 1000.
account displayBalance.
account withdraw: 500.
account displayBalance.

In the above code, we define a class called BankAccount that represents a bank account. It has instance variables owner and balance. The class has methods for initializing the account, depositing money, withdrawing money, and displaying the current balance.

We create an instance of BankAccount named account using the new message. Then, we initialize the account by calling the initialize method. Next, we deposit 1000 units of currency into the account using the deposit: method. We display the current balance by calling the displayBalance method. After that, we withdraw 500 units of currency using the withdraw: method and display the updated balance.

When running this code, you will see the following output in the Transcript (the output window in Smalltalk):

Current balance: 1000
Current balance: 500

This example showcases how to create a simple bank account object, perform operations such as depositing and withdrawing money, and display the current balance. It demonstrates the object-oriented nature of Smalltalk and the ability to encapsulate behavior within methods associated with objects.

Frequently asked Questions

Q1. What is Smalltalk language used for?

Ans: Smalltalk is primarily used for developing software applications and systems. It provides a clean and consistent syntax that focuses on the concept of objects, making it well-suited for modeling complex systems. The language emphasizes message passing between objects, encapsulation, and polymorphism.

Q2. Is Smalltalk language still used?

Ans: Yes, Smalltalk is still used today, although its popularity has declined compared to other programming languages. Smalltalk was one of the earliest object-oriented programming languages and had a significant influence on the development of subsequent languages such as Java and C#. It is known for its simple and elegant syntax, as well as its powerful reflective capabilities.

Q3. What is the difference between Smalltalk and Java?

Smalltalk and Java are both object-oriented programming languages, but they have some fundamental differences:

1. Syntax: Smalltalk uses a simple and consistent syntax based on sending messages to objects, while Java has a more complex syntax with a combination of class definitions, method declarations, and other language constructs.
2. Execution Model: Smalltalk follows a pure object-oriented execution model, where everything is an object and all operations are performed by sending messages to objects. Java, on the other hand, has a mixed execution model with both object-oriented and procedural elements.
3. Virtual Machine: Smalltalk typically runs on its own virtual machine, specifically designed for Smalltalk. In contrast, Java relies on the Java Virtual Machine (JVM), which allows Java code to run on any platform that supports the JVM.
4. Garbage Collection: Smalltalk uses automatic garbage collection, meaning it handles memory management and deallocation of objects automatically. Java also has automatic garbage collection, but it provides more control over memory management through features like explicit memory deallocation using the “finalize” method.
5. Inheritance: Smalltalk supports only single inheritance, where a class can inherit from a single superclass. Java, on the other hand, supports both single and multiple inheritance through classes and interfaces.
6. Libraries and Ecosystem: Java has a vast standard library and a large ecosystem of third-party libraries and frameworks, making it suitable for a wide range of applications. Smalltalk, while having its own libraries and frameworks, has a smaller ecosystem in comparison.
7. Popular Usage: Java is widely used in enterprise applications, web development, and Android app development. Smalltalk is known for its use in educational settings, research, and niche application domains.

Q4. What is the difference between Python and Smalltalk?

Ans: Python is a general-purpose programming language known for its readability and simplicity, while Smalltalk is a pure object-oriented programming language with a highly dynamic and reflective nature. Smalltalk focuses on message passing between objects, while Python adopts a more traditional syntax with functions and methods.

Conclusion

Smalltalk programming is a powerful and expressive programming language that embraces the principles of object-oriented programming. Its simple syntax, live coding environment, and dynamic nature make it a favorite among developers who value readability and flexibility.