The Squeak Language stated informally

In this section I will state and describe the Squeak Language, briefly SL, and do so in two ways, namely first informally in English, and then formally though also in English, but now using a few simple formal conventions for writing formal grammars that will be first explained.

The formal specification supplements the informal exposition, and probably is in fact the easier to follow of the two, for newcomers to Squeak.

The present text is in part derived from the Greenberg-Black specification of the Squeak Language and in part derived from a Backus-Naur specification of Squeak 2.7 on the Squeak Wiki and the ANSI specification of Smalltalk.

A. Informally

The Squeak Language is designed to help people communicate with computers. Computers are machines that can perform certain operations on given inputs that result systematically in outputs. Computer languages tell a computer which operation to perform, and have to be in a form which is valid input for the computing machine while also being as easy to understand for humans as is possible.

The Squeak Language, like any computer language, consists of certain sequences of characters that can be produced by a computer keyboard, but of course not of all any that may be thus produced. Hence a specification is needed for what does and does not count as a term of the Squeak Language. 

 

Common and individual names in SL:

In the Squeak Language there are names much like in other languages. They are called Identifiers, and are made up of sequences of letters or digits, without spaces or underscores:

So any keyboard output that conforms to this specification is an Identifier and functions as a common or individual name of something, which can be assigned to them by Squeak.

Terms in SL:

To this assigning we turn in a moment, but first we introduce a subset of the Identifiers, namely the Literals or Constant Expressions. These have a value assigned to them by Squeak, namely of the followin five basic kinds: 

Characters ............. individual keyboard inputs
Numbers ............... series of characters that represent numbers
Symbols ................ series of characters that serve as constant names
Constant Arrays .. series of arbitrary items of fixed length
Strings .................. series of characters

Note that the specification of Identifiers lays down what may be an Identifier of Squeak, without being here more specific about specific Identifiers. To these we turn now, starting with characters:

So in fact Squeak uses the $ character to indicate that the next item following it is in fact a character in Squeak. (Here it should be realized that inside the computer a character is a glyph - small drawing - associated with a unique number. Hence in effect #hexadecimal means the hexadecimal is a character.)

Next to characters, Squeak uses a fairly standard notation for Numbers, which come in Squeak in quite a few kinds:

What's noteworthy here about numbers in Squeak is that there are quite a few kinds of numbers available in Squeak, including Fractions, and that the notation for reckoning with numbers is somewhat different from what one would expect if one is used to other languages, since Squeak reads its input from left to right and has no operator-strength. So e.g. 2+3*4 is calculated by Squeak as (2+3)*4 and not as (2+(3*4)), though introducing the brackets will in fact force the latter.

Arrays are the basic way for a computer to store groups of things as units. In set-theoretical terms, arrays are sequences or tuples of Squeak-constants, including other arrays. The last statement. that Arrays are indexed with the first element at index 1 comes to this: One may in Squeak get the individual elements of the array by specifying their position in the Array. This will be explained later.

Symbols are a systematic way of creating unique names in SL. The above specification gives some basic variants that are used in SL. The specifications concerning = and == and the colons will be explained later. The special characters are those that may occur in symbols next to digits and capital and undercast letters. The reason #-- is not a symbol while #'--' is a symbol is that -- is not an Identifier while '--' is a string and so when preceded by # is a Symbol as per the first specification.

Note that any computer language has something much like symbols, but there are next to overlaps also variants in what different languages treat as expressions that serve as unique names.

So in fact Squeak uses the ' character to indicate that any sequence of characters inbetween two such characters is a String. This may be initially confusing for many new to Squeak, since in Squeak the conventions concerning ' and " are a bit different than in other languages.

And one must indeed be aware that strings may contain newline characters (that don't display as character but mark the beginning of a new line in a string, that's there for the human readers' convenience) and that the empty string is a string as well. 

These are special terms in SL used nearly everywhere. The given descriptions are explained in part below, with Classes and BlockContexts.

Statements in SL:

Sofar no statements of Squeak have been specified. To this we turn now. First there are Assignments that assign values to identifiers:

One important thing to notice is that ANY expression of SL can be assigned to a SL-identifier and that an SL-identifier works like slot: <Identifier, Expression>. There also is a default assignment namely nil. So in Squeak any Identifier that has been declared has some value given by a Smalltalk expression assigned to it, even if only nil.

Next, the three symbols terms and :=  and _ (underscore) are dealt with by Squeak as assignment of an expression on the right to an identifier on the left.

Then every expression in Squeak has a value that Squeak can produce and calculate, and what is in fact returned if one asks for the value of an identifier what Squeak returns is the value of the expression assigned to the identifier.

Thus, doing Alt-P on

3+4

produces 7

Finally, for this reason

The option to write Comments applies to Squeak code: Squeak will in fact skip anything between two ". A human reader can read it, but Squeak skips it since it doesn't need it.

Now we arrive at Messages, which are the the main Expressions in Smalltalk. They come in three kinds, namely Unary, Binary and Keyword, and come with some conventions:

Messages Unary Messages theta sin quantity sqrt nameString size 1.5 tan rounded asString "same result as (((1.5 tan) rounded) asString)" Unary messages are messages without arguments. Unary messages are the most "tightly parsed" messages, and are parsed left to right. Hence, the last example answers the result of sending #asString to the result of sending #rounded to the result of sending #tan to 1.5

On the first three lines in the above examples the first term is an Identifier and the second a Message, apparently intended to get the sinus, the square root and the size (in some sense) of whatever is identified  by the previous term. 

The last example shows three Unary Messages to be executed in sequence, to the following effect: Take the tan of 1.5, round the result off, and turn the result of that (a number) into a string.

Here we see two of the conventions at work: Smalltalk expressions are evaluated by the interpreter from left to right, using values returned by the left as arguments to the right. 

In fact the same applies to:

Binary Messages 3 + 4 " ==> 7 " 3 + 4 * 5 " ==> 35 (not 23) " 3 + 4 factorial " ==> 27 (not 5040) " total - 1 total <= max  "true if total is less than or equal to max" (4/3)*3 = 4 "==> true — equality is just a binary message, and Fractions are exact" (3/4) == (3/4) "==> false — two equal Fractions, but not the same object" Binary messages have a receiver, the left hand side, and a single argument, the right hand side. The first expression above sends 3 the message comprising the selector #+ with the argument 4. Binary messages are always parsed left to right, without regard to precedence of numeric operators, unless corrected with parentheses. Unary messages bind more tightly than binary messages

Smalltalk in fact deals with "3+4" as "take 3, and add 4 to that". The same applies to "3+4*5", which accordingly has a different value as the same expression has in standard algebra, in which * is supposed to bind stronger than +, so that in ordinary algebra 3+4*5 = 3=(4*5)=23. Of course, if this is what one wants, one can use parentheses in Squeak, for "3+(4*5)" when evaluated by Squeak does result in 23 , as it should.

Also the main Binary Messages in Squeak and Smalltalk are those occurring in standard mathematics, that concern the arithmetical functions, comparisons and identities.

The difference in Smalltalk between "=" and "==" concerns the difference between identifiers and   contents: "==" tests whether two contents are the same (in some appropriate sense); "=" tests whether two identifiers are the same. The same contents can have different identifiers, but the same identifiers cannot have different contents.

Most  messages in Smalltalk are Keyword Messages. Note that these in fact tell whatever is identified by their first term to execute the method plus parameters with values that follows in the keyword messages, for in fact that's what a message is: An identifier followed by the name of a method with parameters with proper values.

In the first line, for example, "12" is send the message "between: 8 and: 15" in wich "between:" and "and:" are parameters, identified by colons as last character, and 8 and 15 are the values of these parameters. (This "between: " the reader can find e.g. by a Method Browser in Smalltalk.)

Having covered Messages, we turn to Expression Sequences - sequences of what we have called statements of Smalltalk i.e. strings that the Interpreter passes as well-formed and evaluates:

Again, an Expression  Sequence can be assigned to an Identifier, which then can be send the unary message value to get the result of evaluating the Expression  Sequence (which as remarked before happens basically from left to right, by first evaluating unary messages, than binary messages and finally keyword messages, and using the results of previous evaluations as input to following evaluations).

This differs from a sequence of Expressions separated by dots, since the dots assure that the next expression is send to whatever is returned  by the previous expression. The term "side-effects" in fact tends to refer to what one sees on the screen, such as a window being drawn, with result "true" (which is ignored in a cascade).

Block are a very interesting and powerful features, basically for three reasons: First, blocks are deferred instructions, waiting to be executed when required;  second, since any sequence of expressions can occur inside them, anything computable can be made into such a deferred instruction; and third the possibility of passing arguments makes the block very flexible.

Those who are not enlightened by terms like "lambda-expressions" might recall the notion of  abstraction in set theory, as in "{x, y :  0<=x+y<=1 }" = "the set of x,y such that the sum of x and y is between 0 and 1 inclusive". Lambda-expressions a.k.a.  lambda-abstraction is a  formalization of this kind of abstraction using formulas and variables.

Incidentally, at the time of  writing - December 2001 - Blocks are not yet fully implemented in Squeak, though there is hope this will happen within a few months due to the efforts of some of Squeak's developers.

This belongs to Blocks as deferred instructions: Having a Block one can execute the code it contains by sending value to it,  plus eventual  parameters.

If control structures must be - sort of - hardcoded inside the language (like Squeak's primitives, say) then the above kinds of ifs are "technically" not  control structures. Apart from that, they are are, and are used all the time.

The point of "Receiver is Boolean" is that what stands to the left of ifTrue etc. must evaluate as true or false, which then may be picked up by ifTrue etc. 

In fact, these ifs are an interesting Smalltalk-feature, that arises out of having the nil option, and that extend the possibilities of  the previous list of ifs, in that they can be send to anything, and not  just to a Boolean. Here the reader should remember that any variable is initialized to nil by Squeak.

This corresponds to similar structures in other languages, though it must be repeated again that control structures in Squeak and Smalltalk are implemented in an original way (using the class Boolean: Check it out in a System Browser in Squeak.) 

This also corresponds to similar structures in other languages. Here one also sees how code is written in Squeak: The first example requires a number to its left and the second is in fact an instance of the third. Note that both "stop" and "step" are parameters.

This is a most important control structure, that allows one to iterate a block over the contents of tje receiver.

This again corresponds to similar structures in other languages. The reason for blocks to occur here is their power, and the reason for the associations is that it enables one to immediately associate what the programmer want to be associated to the cases found.

As the name indicates, braceArrays are a sort of array the contents of which are evaluated by Squeak (and not just retrieved).

An alternative name is Return. Note the second point, and remember that a return-expression inside a block need not be reached during execution of the method.

In fact, this is the format the browsers propose and pop up when one starts writing a new class, which one has to fill by specifying one's own terms after the colons. The above is best understood by browsing the system and seeing how classes are in fact written. (Incidentally, poolDictionaries seem to be hardly ever used in Smalltalk, while "category" refers to one's organization of one's classes in the browser: They are not used in programs.) 

The general point is that methods are meant to get values by executing them, and the implicit  ^self at the end of every method assures that this will happen whenever it is executed.

Link to: The Squeak Language stated semi-formally- that may be somewhat clearer, perhaps, and in any case supplements the present exposition.