Self

David Ungar and Randall Smith launched Self in 1987, a project that would challenge conventional wisdom. This new language deliberately rejected everything that seemed established at the time. Classes were gone, variables forgotten. Only objects and their conversations through messages remained.

This radical approach wasn't gratuitous. It arose from frustration with the growing complexity of object-oriented systems. Smalltalk-80, though admired for its elegance, carried the burden of its meta-classes and their dizzying interconnections. Self proposed a different vision: why bother with molds when you can sculpt directly in the material?

In this streamlined universe, each object is a container of named "slots." These slots store data and behaviors indiscriminately. Inheritance relies on simple "parent" pointers that create delegation chains between objects. A system so simple it's bewildering.

Object creation follows natural logic. Instead of consulting a class blueprint, Self directly clones an existing prototype. This approach resolves at once the famous infinite regression of meta-classes that gave Smalltalk designers cold sweats. One object serves as a model for other objects, period.

Uniformity constitutes the other pillar of this architecture. Whether an object requests stored information or triggers a complex computation, the syntax is identical: sending a message. This consistency blurs the traditional distinction between properties and methods. The programmer navigates a homogeneous world where every interaction follows the same rules.

Self's early implementations surprised with their performance. By 1989, the language caught up with and then surpassed Smalltalk in execution speed. This success concealed a discreet but decisive technical innovation. The team invented "maps," internal structures that optimize how objects are organized in memory. These hidden maps are what would later be called "hidden classes."

Customized compilation pushed optimization even further. Instead of producing generic code, Self generates machine code tailored specifically for each type of recipient. This dynamic specialization transformed the language's performance.

Polymorphic inline caches emerged in 1991. These PICs memorize multiple method resolutions for each call site. Concretely, when a message can lead to different processing depending on context, the system keeps previously found solutions in reserve. Polymorphic calls, traditionally expensive, suddenly became affordable.

The 1996 version reached a new milestone with "type feedback" and adaptive optimization. The first mechanism integrates dynamic calls directly into compiled code, reducing method invocations by 70%. The second observes the program in action and reworks on the fly the most heavily used passages.

These technical advances caught Sun Microsystems' attention. In 1991, the company recruited Ungar and Smith to continue their research. But the story took an unexpected turn when two key project figures, Urs Hölzle and Lars Bak, left Sun in 1994 to create Animorphic Systems. Their mission: develop Strongtalk, a high-performance Smalltalk.

Sun's acquisition of Animorphic in 1997 sealed the fate of Self's innovations. They migrated to HotSpot, the virtual machine that would propel Java to the heights. Lars Bak repeated the feat in 2008 with V8, Google's JavaScript engine, which also drew from Self's heritage.

This technical lineage constitutes only part of the story. Self also influenced language design. JavaScript adopted prototypes as its primary inheritance mechanism. Lua, Io, and other modern languages drew inspiration from this direct approach where objects beget other objects without intermediaries.

Self's philosophy of concreteness is reflected in its development environment. Objects appear there as tangible entities, visible and modifiable in real time. This innovative graphical interface transformed programming into a tangible activity. You touch, you move, you transform. Abstraction gives way to direct manipulation.

Simplicity, uniformity, and concreteness are the three principles guiding this vision. Reduce the number of concepts, treat all operations identically, use comprehensible metaphors. These simple ideas produce an environment of surprising richness.

Self never conquered the programming masses. Too radical for some, too experimental for others, the language remained confined to research laboratories. Yet its influence spans decades. The optimization techniques it introduced now allow dynamic languages to rival their compiled cousins. Python, Ruby, PHP benefit from its innovations.

This singular history shows how a quest for simplicity can trigger a cascade of lasting innovations. Self demonstrated that sometimes everything must be torn down to move forward. Its minimalist design anticipated certain current trends where conceptual streamlining takes precedence over feature accumulation.

Self's technical legacy powers the most performant virtual machines on the market. Its philosophy inspires designers seeking elegance. Forty years after its birth, Self remains a source of inspiration for those seeking to rethink object-oriented programming.