If you are new to computer programming, don't be intimidated by the somewhat rushed summary given below. Just read it once or twice to get a general feel for things, and don't worry if you don't understand everything you read.
The benefits of the "everything is an object" philosophy are great, and pure languages such as Smalltalk are considered to be more productive and (more importantly) more fun to program in.
Smalltalk is fundamentally tied to automatic dynamic memory management, and as such must be supported by an underlying automatic memory management system. In practical terms this means that a Smalltalk programmer no longer needs to worry about when to free allocated memory. When finished with a dynamically allocated object, the program can simply "walk away" from the object. The object is automatically freed, and its storage space recycled, when there is nothing else referencing it.
Smalltalk has a uniquely simple and elegant syntax for expressing message sending. There are three possible forms:
5 timesRepeat: [self print: 'Hello world!']. primes := (1 to: 100) select: [:number | number isPrime]. #('mary' 'had' 'a' 'little' 'lamb') do: [:string | self print: string] separatedBy: [self space]. [self shouldContinue] whileTrue: [self performAction].The important thing to note here is that all control flow constructs are implemented as messages interpreted by various kinds of objects. For example, 'timesRepeat:' is a message understood by integers.
Since everything in Smalltalk is an object, everything has a class. For example, the number 5 has a class named Integer. The string 'hello' has a class named String, and so forth. You can define your own classes and create instances of them. You can find out what class any object belongs to by sending it the message 'class'.
Classes themselves are instances of other classes called metaclasses. Metaclass programming is a relatively advanced part of Smalltalk programming, but it can be used to achieve some important effects. The Smalltalk class browser makes both "ordinary class" and metaclass programming quite easy.
When you program in Smalltalk, you spend most of your time creating and modifying class definitions. In the Smalltalk class browser window, you can associate message names (also called selectors) with Smalltalk program code fragments (also called methods). A class, therefore, is a mapping between selectors and methods. When an instance of a class receives a message, it consults its class to see which method it should invoke in response to the message.
A very important ability of Smalltalk classes is that they can inherit from other classes. This reflects the observation that most objects can be viewed as specializations of more general objects. For example a character string like 'hello' can be viewed a a collection of letters (characters). Therefore, the String class inherits many of its abilities from another more general class called Collection. Every class inherits from exactly one other class (this is known as single inheritance, in contrast to the multiple inheritance of C++, Self, and to a lesser extent Java). Every class therefore inherits abilities from another class, called its superclass. There is one exception to this rule: the class called Object has no superclass. Therefore, every other class ultimately inherits from Object. Inherited abilities are themselves inherited, so superclasses can be "nested" to any depth. For example the Integer class inherits from Number, which in turn inherits from Object.