What Makes Smalltalk Considered Elegant

Smalltalk is often regarded as elegant due to its simplicity and consistency in design. This elegance resonates with the principles that made Lisp famous, where everything is a list. However, being elegant does not guarantee correctness or practical utility. This article explores the simplicity and power behind Smalltalk's design and provides examples to illustrate its unique features.

The Essence of Smalltalk's Design

The elegance of Smalltalk lies in its fundamental principle that everything is an object. In contrast to Lisp, where everything is a list, Smalltalk's simplicity revolves around objects and the message-passing paradigm. This means that objects can send and receive messages, and operations are performed through method invocations rather than direct syntax.

Object-Oriented Homogeneity

In Smalltalk, every value is an object. This uniformity simplifies the programming model, making it easier to design and reason about programs. Here are some examples that demonstrate this:

Transcript show: Hello worldCounter new: count 1

In these examples, "Transcript" and "Counter" are objects that perform specific actions when messages are sent to them. This consistency in design adds to the elegance of the language.

Natural Syntax and Operator Overloading

Smalltalk's syntax is straightforward and doesn't introduce additional complexity. Operators in Smalltalk behave according to a left-to-right evaluation order, which means you can write expressions naturally. However, this can sometimes lead to behavior that deviates from intuitive expectations if not understood thoroughly.

Arithmetic with a Twist

Smalltalk's arithmetic operations are performed through message passing. This can result in behavior that differs from what one might expect from more conventional languages. For instance, consider the following:

1   2   3

In Smalltalk, this would evaluate to `1 message ' ' with: 2 message ' ' with: 3`. This can yield unexpected results when mixed with standard arithmetic operators:

1 2 3

Here, `1 2 3` would evaluate to 6, but `1 2 3` would actually evaluate to 7 because it's interpreted as `1 message ' ' with: 2 message ' ' with: 3`.

Comparison with Lisp and Other Object-Oriented Languages

To better understand Smalltalk's elegance, it's helpful to compare it with languages like Lisp and Ruby. Both Lisp and Smalltalk emphasize simplicity and powerful capabilities through their design. Moreover, the flexibility and expressiveness offered by macros in Lisp and message passing in Smalltalk share a similar goal of making code more manageable and understandable.

Metasystematic McGyvering

While Smalltalk might not be the most widely used language today, its design principles have influenced many modern systems. The ability to create complex functionality through simple, consistent rules makes Smalltalk a powerful tool for metasystematic approaches—essentially, using the language to manipulate itself.

Conclusion

The elegance of Smalltalk lies in its simplicity and the consistent application of object-oriented principles. While this elegance doesn't automatically equate to practical utility, Smalltalk's unique design offers a powerful and flexible foundation for programming. Whether you're interested in object-oriented design, metaprogramming, or just love a language that is both simple and expressive, Smalltalk is a language that you should explore.

Further Reading

For those who want to dive deeper into Smalltalk, the official documentation and the language's open-source implementation, Squeak, provide excellent resources. Additionally, textbooks like Smalltalk Best Practice Patterns by Ben-Hyon Lee can offer valuable insights into best practices.