Which Was The First Purely Object-Oriented Programming Language?

To know more about Smalltalk, its birth, concepts used in Smalltalk, and why it is the first purely Object-Oriented Programming language read this article.


The first purely Object-Oriented Programming language is Smalltalk. Smalltalk is a language that was created in 1980. The first version of Smalltalk which was developed is called Smalltalk-71. Smalltalk is inspired by Simula. Later Smalltalk-76 was developed which was again adapted from simula and used the class concept of simula.

Smalltalk-76 had a class library. Later Smalltalk-80 was developed. In Smalltalk-80 metaclass was included and supported objects. Smalltalk is one of the Object-Oriented Languages. Smalltalk supports the Agile framework, RAD framework, and Software Design Patterns.

Smalltalk provided the base to develop many of the Object-Oriented design patterns. One of the most used design patterns is model-view-controller. The model-view-controller is used to develop the user interface. Smalltalk also influenced the programming of the graphical user interface (GUI). Smalltalk has built-in debugging tools and tools that can be used to inspect objects.

Smalltalk is based on class and object concepts. In Smalltalk, an object is an instance variable of a class. Object behavior and its property are based on the class definition. An object of Smalltalk can hold the state of the object, can take messages from other objects, and can transmit messages to itself or another object. In Smalltalk objects, private values are not shared. The state of the object can be changed if it is required. The state of the object can be changed using the Live coding methodology.

Smalltalk is a pure object-oriented language meaning that there exists no distinction between objects and primitive types. In Smalltalk primitive types such as integers, booleans and characters are also considered as objects of a class. The objects of primitive types can undergo a change in state by sending messages to them. Smalltalk also supports subclassing. In Smalltalk, all the values are objects so classes are also considered objects. In Smalltalk, Code blocks are also considered as objects.

Smalltalk has the feature of inspecting object values using this feature in-memory objects can be inspected. Using inspect feature code of Smalltalk can also be viewed and intermediate results can also be checked which is generated during parsing/compilation. In Smalltalk parse trees can also be inspected that are generated during parsing/compilation. The class and functions in Smalltalk are also objects in Smalltalk. Smalltalk can add classes at runtime.

Objects in Smalltalk can be inspected and can be copied from one object to another object and can be serialized and deserialized. Inspecting object values can be used to handle errors.

Smalltalk consists of six keywords and they are as follows – true, false, nil, self, super and thisContext. These keywords are also called pseudo-variables and their meaning can not be changed by programmers.

Smalltalk supports integer, binary and hexadecimal values. To use characters they must be preceded by a $ sign. To use strings it must be enclosed within strings. Smalltalk supports symbols and all symbols are distinct.

Smalltalk also supports arrays. Arrays can take integer values. Programming instructions in Smalltalk are written in blocks.

Smalltalk supports instance variables and temporary variables. In Smalltalk variables that are declared within the method are called temporary variables. Temporary variables are declared at the beginning of the method and enclosed by blank spaces at both ends and within vertical bars and to declare more than one variable they are separated by blank space but within the same vertical bars.

Variables can also be assigned values using assignment operators. In Smalltalk assignment operator is denoted like this “:=”. 

Smalltalk also supports inbuilt functions in the form of messages. To call a particular inbuilt function message is written. The messages are written using usual English. The definition of messages is given in the Smalltalk compiler.

Expression in Smalltalk is written using multiple messages. The expression can be built using Unary messages, binary messages, and keyword messages. These messages have predefined precedence, in which Unary message comes first, second is binary message followed by third one that is keyword message.

In Smalltalk, programming instructions are written within square brackets. Within the square brackets list of parameters is declared followed by a set of programming instructions. Blocks are helpful in writing codes that will be repeated again and again. That is an iterative statement written within code blocks. With the help of blocks, polymorphism can be implemented. With the help of polymorphisms, different alternatives can be selected. Smalltalk also supports if-then-else statements consisting of true block and false block. For if-then-else statements to be executed expression is evaluated if the statement is true then the true block is executed else false block is executed.

Smalltalk also supports exception handling that can be written within blocks.

Smalltalk classes used to be first-class objects and these classes can interact with other classes. Objects of these classes pass messages to classes and these objects can be created dynamically.

Objects of Smalltalk can invoke messages. Smalltalk supports dynamic binding or it can be said that Smalltalk can support runtime binding; it means messages to be executed are determined at run time. Thus Smalltalk supports late binding.

Objects of class in Smalltalk support instances of classes. To create an object of a class MessagePublisher message is used with a new keyword.

Smalltalk also supports garbage collection where unused memory can be managed at runtime. When Smalltalk programs are executed it gets converted into bytecode. This byte code is converted into machine-native code.

Smalltalk is the base of many languages like C, Python, Ruby, Java, etc. Smalltalk has its application in web applications, IoT, Medical files, Mobile apps, etc. Smalltalk also supports graphic programming and has extensive use in web development.

There exist many Smalltalk Systems belonging to different categories such as open-source as well as commercial. Many Smalltalk based applications have been developed that are deployed in small and large companies. Smalltalk is also used to develop web and mobile applications. 

There exist many Smalltalk versions that are free as well as commercial. These are as follows:

  • OpenSource (License)
  • Pharo Smalltalk (MIT)
  • Squeak Smalltalk (MIT)
  • Cuis Smalltalk (MIT)
  • GNU Smalltalk (GPL)
  • Dolphin Small  (MIT)
  • Amber Smalltalk (MIT)
  • Redline Smalltalk (MIT)
  • Essence#Smalltalk (BSD)
  • Little Smalltalk (Various, Public Domain)

A few of the Smalltalk milestones include:

  • Language virtual machine is based on Smalltalk and on this language virtual machine Java and Ruby are based.
  • The just-in-time compilation is based on Smalltalk.
  • The first IDE is based on Smalltalk, this IDE includes a debugger, an object inspector, a browser, and a text editor.
  • The first code inspection technique was introduced in Smalltalk.
  • Smalltalk also supports functional programming.
  • Smalltalk introduced a software development architecture called Model-View-Controller (MVC).
  • Smalltalk builds the bases to develop object databases.

Smalltalk is used by many organizations such as:

  • JP Morgan
  • UBS
  • Texas Instruments
  • BMW