Smalltalk is an object-oriented programming language. Indeed, Smalltalk is so object oriented that it’s barely a procedural imperative language: Smalltalk’s syntax doesn’t even have conditionals or loops! How is that possible? Well, you don’t need loops in the syntax of your language if block (lambda) objects have a whileTrue method which runs the block repeatedly, and you don’t need conditionals if your boolean objects have an ifTrue method that evaluates its argument only if the boolean was true. If you’re familiar with object-oriented languages that have a less pure approach to object-oriented programming (that is, nearly all of them), then Smalltalk’s style will come as a bit of a shock. But, it doesn’t take much getting used to, and before you’ve grown accustomed to it, you can simply mentally rewrite the conditions and loops you’re comfortable with into Smalltalk’s style.
Smalltalk’s oddness doesn’t stop there, however. Smalltalk is a class-based object-oriented language, as are C++, Java, Python, etc. You might then assume that a reasonable place to start with such a language is “what is the syntax to define a class?” Except... there isn’t one. The Smalltalk standard does not include syntax for classes. Smalltalk was, at its inception, not just a programming language, but an operating system and development environment, and the way that you create a class is through the graphical workspace. You then add methods to the class through user-interface interactions, and then finally, the body of a method has a defined syntax. In order to reduce the semantic leap from languages that you may be more familiar with (and, quite frankly, to make it more gradeable), in this course, we’ll be using an unusual variant of Smalltalk that behaves more like a conventional programming language, GNU Smalltalk. GNU Smalltalk accepts Smalltalk files and has an interactive REPL, like other programming languages. If you’re interested in Smalltalk, you’ll probably want to explore some other Smalltalk environments, such as Pharo (https://pharo.org/) and Squeak (https://squeak.org/), but bear in mind that only the syntax for the bodies of methods will look familiar.
This module assumes that you’re familiar with some modern object-oriented languages such as C++ and perhaps Java, and that you’re familiar with programming in general, and focuses on what will be unfamiliar in Smalltalk with that background.
GNU Smalltalk on linux.student.cs.uwaterloo.ca is provided by CS442, in /u/cs442/students. To add it to
your environment, use source /u/cs442/students/env.sh, or simply add
/u/cs442/students/inst/bin to your PATH. Then run the command gst:
$ gst
GNU Smalltalk ready st>
You may also want to install GNU Smalltalk on your own system. In most systems with package managers, it’s in a package named gnu-smalltalk. Or, you can get the source at https://www.gnu.org/software/smalltalk/ and build it yourself. You should get the latest “alpha” version, which at the time of writing this is 3.2.91. Unfortunately, the latest release has a bug printing floating-point numbers; see the discussion in Section 8 on floatfix.st. This bug has been fixed in the version in /u/cs442. Note that the student servers sometimes have /usr/bin/gst as well, but you should make sure to use the version in /u/cs442 because of this bug.
From here, we can write everyone’s favorite first program:
st> 'Hello, world!' displayNl Hello, world! 'Hello, world!' st>
That... kind of worked? It actually worked fine: the first line is the behavior of the displayNl method itself, and the second line is the return from the displayNl method. displayNl returns the thing that it displayed.
Let’s take a moment to examine how this worked, though, because it probably looks unfamiliar. Our command, 'Hello, world!' displayNl, has two components: the string and the message. The string should look familiar enough, but it’s worth noting that in Smalltalk, strings can only be delimited by single quotes ('), not double quotes ("). In addition, strings in Smalltalk are objects of the class String.
In fact, everything in Smalltalk is an object! Yes, even the class String itself is an object, of the class Class! And, of course, the class Class is itself an object, of, you guessed it, the class Class.
The second part is the message. This command sends the displayNl message to a string object. When an object receives a message (in this case, displayNl), it looks up a corresponding method in its class. String objects are of the class String, so String’s displayNl method is invoked (sometimes written String>>displayNl to clarify which class’s method is meant), and the result of the expression ('Hello, world!' displayNl) is the return value of the method. This whole process should feel familiar if you’ve used any object-oriented language, so rather than describing the whole process of sending a message and responding by invoking a method every time, we will simply describe this process as “calling the displayNl method”1 .
Smalltalk is quite purely object oriented: there are no procedures that aren’t methods, and there is no control flow but calling methods and returning. So, if methods are all that there is, then the way to display a string is to call the display method on the string—i.e., ask the string to display itself. If C++ supported this style of displaying strings, it might look something like this:
The parentheses and dots and other syntactic clutter are there because C++ has so many other ways of expressing yourself. When all you can do is call methods, you don’t need a dot or parentheses to say that you’re calling a method. Of course you’re calling a method; that’s all you can do! So, all that extra syntax falls away, and the simple way to call a method is just to name it: 'Hello, world!' displayNl.
Since single quotes delimit strings, if you want to put a single quote in a string, you need to escape it (specify that this single quote is not the end of the string). To do so, simply use two single quotes instead of one:
st> 'This isn''t SUCH a bad programming language!' displayNl. This isn't SUCH a bad programming language! 'This isn''t SUCH a bad programming language!' st>
Note that the string it actually printed had only one single quote. The second line is showing what value was returned by displayNl, and to show that a string was returned, it surrounds it in quotes, and escapes the quote again.
You can use Ctrl+D or the extremely memorable command ObjectMemory quit to leave the GNU Smalltalk interactive shell. We’ll mostly be using Smalltalk files, since Smalltalk was never really meant to be used in a read-eval-print-loop (REPL) like this.
Aside: The Nl in displayNl means “newline”. If you didn’t want to print with a newline at the end, just use display!
Create a file named math.st (or whatever you’d like) in your favorite text editor. Let’s write a program to do some basic arithmetic:
And run it:
$ gst math.st
That result was probably not what you expected. The reason is that everything in Smalltalk is an object, so all behaviors are method calls, even +. It should be clearer if we add some parentheses to show the precedence:
A zero-argument method call like displayNl binds more tightly (has higher precedence) than a binary method call like +, so it came first. Let’s rewrite this in C++-like method-call syntax to show every step:
The displayNl method was applied on the 12, and then its result was passed to the + method on 30. On the interactive shell, we would have also displayed the result of the whole computation, which is 42, but now that we’re writing actual Smalltalk files, the only output that’s displayed is what you explicitly ask for. We can fix this with parentheses (which, contrary to many other languages, are never method calls). We can also clarify our code with a comment, which in Smalltalk is surrounded by double quotes:
OK! By putting (30 + 12) in parentheses, we’re forcing it to be evaluated first. Then, the displayNl method is called on the result, 42. Now, let’s do some very slightly more sophisticated math:
Once again, a surprising result. If we apply the usual rules of math, then * has higher precedence than +, so we would perform 6 * 2, then 30 + 12. But, this isn’t (just) math, and + and * aren’t just operators, they’re methods. Smalltalk doesn’t actually know the rules of mathematical precedence, it just knows how to call methods on objects. In this code, it just knows to call the + method because you asked it to, and then call the * method because you asked it to. In fact, Smalltalk doesn’t even know what the mathematical operators are; if you want to use @ as an operator for your own class, you just need to name a method in that class “@”.
Since it knows nothing of the order of operations, Smalltalk treats all binary operators with equal precedence, going left to right. We can now fix our simple math with even more parentheses:
Since displayNl returns the object being displayed, we can actually observe this left-to-right behavior quite nicely, by printing the result of every intermediate calculation:
We can perform multiple statements by separating them with a dot (.). In essence, you can think of the dot like a semicolon (;) in C and languages that follow its style:
It is not necessary to end the last statement in a list of statements with a dot, but it is common to do so.
It should come as no surprise that Smalltalk has two boolean values: true and false. By this point, it should hopefully also not come as a surprise that true and false are objects of the class Boolean, and they have some useful methods.
In most modern programming languages, using a boolean to conditionalize execution looks something like this:
In Smalltalk, there are no conditional statements like this in the syntax. Instead, just like everything else, we do things conditionally by calling a method. In this case, the isTrue: method on Booleans:
This example has introduced two new elements of Smalltalk syntax. First, the simple one. Note the : on ifTrue:. Methods named with a colon like this expect an argument. Of course, in this case, the interesting part is what that argument is.
Now, the more interesting new element. The expression ['true is true!' displayNl] defines a block. A block is sort of like an anonymous function, in that it is a packaging of code which can be evaluated later, but this analogy is imperfect, so we’ll simply use the standard Smalltalk term, “block”. We pass that block as an argument to the ifTrue: method. Like an anonymous function, ifTrue: can then choose to call it, or not to call it.
You may think that the implementation of ifTrue: has to “cheat” and do a conventional if statement to work. In fact, its implementation is far more object-oriented than that. The object true is actually of the class True, which is a subclass of the class Boolean. Some methods are implemented on Boolean, and those can be used on true: like in other class-based languages, subclasses inherit the behavior of their superclasses. But, the method ifTrue: is implemented on True, and all it does is evaluate the block passed as its argument. It doesn’t need to check if the boolean is true. It knows it’s true because this is a method on the True class, and only true is of the class True. Conversely, the method ifTrue: on the False class does nothing.
A block boxes up code, and it only runs the code if some one asks for it. It gives us a way of making it optional to execute the code at all.
Since both True and False support the ifTrue: method, but ifTrue: only evaluates its argument on True, this allows us to conditionalize the execution of a block, with nothing but objects and methods!
Let’s put this together with our math from before, adding the operators for comparing numbers:
Equality and inequality work on all values, but the rest are specific to numbers. Remember when using these operators that they simply evaluate left-to-right. There is still no operator precedence:
These error messages can be a bit dense, but only the first line really matters: true doesn’t know how to +, and because Smalltalk evaluates left-to-right, we tried to perform + 9 on the true that was a result of 10 + 10 > 10. As usual, we can fix this with more parentheses:
You can build a lot out of ifTrue:, but it doesn’t have an “else” branch. Booleans also have two other methods, ifFalse: and ifTrue:ifFalse:, which cover other cases:
These hopefully behave as you would expect them to, but note how the call to ifTrue:ifFalse: looks. First is the operator which generates the true on which we’ll be calling the method. Then comes ifTrue:, then comes the true argument value (a block), then comes ifFalse:, and then comes the false argument value (another block). This style of method call syntax is Smalltalk’s second greatest difference from more popular languages. Because parameter names and argument values can be intermixed in this way, it’s very important to make sure you put a dot at the end of your statements. If you don’t, the error messages can be extremely confusing.
Video 1.s.2 (https://student.cs.uwaterloo.ca/~cs442/W23/videos/1.s.2/): ifTrue:ifFalse:
Generally speaking, Smalltalk programmers try to name their methods such that, with the actual argument values in place, it reads a bit like an English sentence. For instance, on arrays (which we will look at in more detail later), the method to put a value into the array at a given location is at:put:. This would be written my-array at: the-position put: my-value. This reads as “in my array at the position put my value”.
Now we’ve done conditions, but not loops. The simplest way to loop in Smalltalk is over a numerical range:
Note our new addition to blocks. Like methods, blocks can take arguments. Block arguments are labeled with : at the beginning of the block, and the list of block arguments is ended with |.
Of course, this can be mixed with math:
What if I need to do a more sophisticated loop? Like any other programming language, it’s possible to loop while some condition is true (or while some condition is false), but to learn how to do that, first we’ll have to introduce variables, so our condition can actually change.
To declare variables, surround them in pipes (|). To assign to them, use :=.
Of course, this isn’t an especially intersting use of variables. Let’s use variables and math to make a more interesting loop:
One major difference from our conditionals (ifTrue:ifFalse:) is worth noting: our condition itself is in a block! Why did we need it in a block here, and why didn’t we need it in a block before? The answer is simple, but not obvious: anything that needs to be run repeatedly needs to be in a block. In order to check whether x < 64 multiple times, we need to put it in a block, so that block can be made to run repeatedly, re-checking whether x < 64 every time around the loop. Of course, the block given as an argument to whileTrue: is also evaluated multiple times! There’s also a whileFalse:, which behaves as you’d expect.
Smalltalk has various standard containers, including lists, arrays, strings (which are arrays of characters), and dictionaries.
Although various Smalltalk classes are implemented as lists, the most frequently useful list type is OrderedCollection. Until now, we’ve only created objects implicitly—numbers are objects, blocks are objects—but never explicitly built an object from a class. As with everything, the way to build an object from a class in Smalltalk is to call a method on the class; usually, the new method. Thus, we create an OrderedCollection with OrderedCollection new:
The display format for an OrderedCollection is simply OrderedCollection followed by its elements in parentheses.
Add elements to an OrderedCollection with add::
You can also use addFirst: to add to the beginning of the list instead of the end. If you have another collection (whether an OrderedCollection or not), you can add all of its elements with addAll:. You can concatenate two lists into a new list with the , operator:
Alternatively, you can use with: (or with:with:, etc) while building the OrderedCollection to create a list and add elements in one step. Loop over the list with do::
You can access members of the list directly with at:, and get the number of elements in the list with size:
Note that lists—and all other collections in Smalltalk—are 1-indexed, not 0-indexed, so the first element is at: 1. In this example, our error was using at: i after the loop, since at that point, i > lst size. As before, the first line tells us what we need to know: “Invalid index 3: index out of range”.
You can also change an element in an OrderedCollection with at:put::
Finally, you can remove the first or last element of a list with removeFirst or removeLast respectively. These methods return the removed element, so are useful for using the list as a queue or stack.
Lists are lists, so indexing with at: is slow, but adding elements with add: is fast.
Arrays are of a fixed size, and their size must be declared when they are created. As such, rather than a simple new method, Arrays have new:, which takes the size as an argument:
Note that before we’ve put a value into a slot of the array, the value is nil. nil is similar to null, nullptr, or NULL in other programming languages. But, nil is a fully-fledged object with methods and a class. You can check if a value is nil with a normal comparison, e.g. x = nil, but it is more common to use the isNil method, e.g. x isNil, which returns true only for nil.
Arrays can also be created simply with array literals, which are written with braces, with the elements separated by dots:
Because their size is fixed, Arrays don’t support add: or its variants. However, every other OrderedCollection method shown in the previous section behaves the same as in OrderedCollections, including concatenation. Arrays are arrays, so indexing and mutating with at: is fast, but adding elements is so slow that the language has simply prevented it!
It is common to convert back and forth between OrderedCollections and Arrays to benefit from each kind’s advantages when needed. All collections have an asOrderedCollection method to convert to an OrderedCollection, and an asArray method to convert to an array:
Aside: Array is actually a subclass of OrderedCollection which replaces its internal data structure with an array instead of a list. OrderedCollection is the generic superclass of all ordered collections, but is also a fully implemented list class itself. This is why OrderedCollection has a strange, generic-sounding name, while Array has a very precise, descriptive name.
We’ve already seen strings: they’re delimited by single quotation marks ('). In fact, strings are just a special kind of read-only Array, an Array of Characters. Anything you can do with an Array, you can do with a String, except that you cannot change it:
We can convert a String to an Array and vice-versa, usually in order to make it modifiable. To specify an element of the Character type, prefix the character with a dollar sign ($):
Program | Output |
| s | s := 'Hello, world!' asArray. s displayNl. s at: 13 put: $?. s := s asString. s displayNl.
| ($H $e $l $l $o $, $ $w $o $r $l $d $! ) Hello, world?
|
Any character after a $ will be taken as a character literal, so, for instance, you can get a literal newline like so:
Using $ like this is usually considered to be in poor form, however, so the Character class also has a constructor that directly creates a newline character, lf:
Video 1.s.4 (https://student.cs.uwaterloo.ca/~cs442/W23/videos/1.s.4/): Ordered collections
Smalltalk also supports key-value maps, called Dictionarys. Any value can be used as a key, and a single Dictionary can contain keys of multiple types, though most dictionaries in practice only use one.
Create a Dictionary with new, and add key-value associations with at:put:, like other collections:
In addition, you can check whether a key is present with includesKey:, and remove a key-value pair with removeKey:
You can loop over Dictionarys with do:, like other collections, but the block will only receive the values, not the keys. To loop over both keys and values, use keysAndValuesDo:, which takes a two-argument block (which we haven’t seen before):
Note that in two-argument blocks, the space between an argument name and the next : is mandatory.
Until this point, our focus has been on learning the syntax of Smalltalk and how to use its built-in types. Now, let’s make our own type. We will make a “reverse Polish notation” calculator.
If you’re not familiar with reverse Polish notation (RPN) calculators, they are a form of calculator which represents its input as a list of commands which operates on a stack. A number is a command to push that number to the stack, and an operator is a command to pop two values from the stack, perform the relevant operation, and then push the result onto the stack. For instance, the mathematical expression 1 + 2 ∗ 3 is written in RPN as 1 2 3 * +, and (1 + 2) ∗ 3 is written as 1 2 + 3 *.
Naturally, our RPN calculator will need a stack. It will need a method to push a number onto the stack, and methods for each of the supported operators.
The first question is, how do we create a new class? Naturally, we call a method on an existing class! Namely, the subclass: method. As there’s nothing in particular our RPN calculator should be a subclass of, we’ll just make it a subclass of Object, the base class:
We can verify that our new class does in fact exist:
“a RPNCalculator” is simply the output of Object>>display, the general-purpose display method that works—albeit not usefully–on all objects. The odd # thing is called a “symbol”, and is essentially just how you represent a string that’s intended to be used as a name in Smalltalk. Other than this one use and in error messages, you’re unlikely to ever need symbols.
It’s a bit pointless to create a subclass with absolutely nothing in it, of course. You can go one-by-one through the desired methods of the class and add them all, but GNU Smalltalk offers a shorthand for defining a method in a somewhat more familiar style:
This program creates a class named RPNCalculator as a subclass of Object (and note that in this shorthand, no # is needed), makes instances of the RPNCalculator class have the field stack (actually called an “instance variable” in Smalltalk), and adds a method push: which adds its argument to the stack (assuming that the stack is simply an OrderedCollection). This snippet also shows how to return a value from a method: with a carat (^).
We haven’t made our constructor yet, but to do so, we’re going to have to understand one crucial detail about Smalltalk: Smalltalk instance variables (fields) are always private. There is no syntax to access an instance variable of another object. But, the constructor is a method of the class, not a method of objects of the class (think of OrderedCollection new), and so it can’t access the instance variables even of the object it’s creating. Because of this, it’s common for constructors to be in two parts: the class has the constructor, and instances have an initializer. The initializer can access its own instance variables, so the constructor calls the initializer. We’ll demonstrate this by adding a constructor for RPNCalculator:
There are a few things to note about this example:
Now, we’d like to be able to do math. Let’s start with addition:
This method pops two elements from the stack with removeLast, then adds them, then pushes the result onto the stack, and returns the result. We can—and will—write methods for each of the usual operators, but they’ll all be doing the same thing: pop two values, do a calculation with them, then push the result. Surely there’s some way we can write this so that we don’t write the same code over and over again? Of course there is: we need to use blocks! Blocks allow us to box up a calculation, like an anonymous function, and boxing up the actual calculation so we can separate it from the stack behavior is exactly what we want to do. We can write a generic “binary operator” method that takes a block as its argument, and expects the block to do the correct calculation. As yet, although we’ve passed blocks to other methods, we haven’t actually evaluated blocks ourselves, so we’ll have to learn how to do that, too.
At this point, you should be able to guess how you evaluate a block. You call a method on it, of course! Specifically, the value method if it’s a zero-argument block, the value: method if it’s a one-argument block, and the value:value: method if it’s a two-argument block. Our block is supposed to perform a binary operator, so it’ll be a two-argument block:
Our new implementation of binary: is almost exactly like our old implementation of add, but it takes an operatorBlock argument, and then calls that block on line 7 with value:value:. Our add method is now simplified to one line: call the binary: method on self (the Smalltalk equivalent of “this”), with a block as an argument which simply adds together its two arguments. The result of self binary: is returned from add.
Now, let’s add the remaining methods for other mathematical operations, and finish our RPN calculator:
Aside: It is generally considered good form in Smalltalk to have many short methods, rather than few long methods. That is, break methods down into their minimal useful components.
Now we have a few options for using and testing RPNCalculator. First, assuming we’ve stored this in a file named rpncalc.st, we can use it on the GNU Smalltalk REPL by running gst with the argument -:
$ gst rpncalc.st - GNU Smalltalk ready st> | x | st> x := RPNCalculator new. a RPNCalculator st> x push: 1. 1 st> x push: 2. 2 st> x push: 3. 3 st> x mul. 6 st> x add. 7 st>
As you may guess from that command line, you can also write tests in a separate .st file, and run both with gst rpncalc.st tests.st. Finally, you can write more sophisticated tests using the built in testing framework SUnit (https://www.gnu.org/software/smalltalk/manual/html_node/SUnit.html).
Video 1.s.5 (https://student.cs.uwaterloo.ca/~cs442/W23/videos/1.s.5/): RPNCalculator
Our RPNCalculator is mostly ambivalent to the kind of number you pass in. GNU Smalltalk actually has several ways of storing numbers: integers, precise fractions, and floating-point numbers. Unfortunately, the different kinds of numbers don’t always behave well when you mix and match, so if we want our calculator to be robust, we should make sure that incoming numbers are of a predictable type. We can do this by making subclasses of RPNCalculator which override push:, but convert to the desired type:
Unsurprisingly, asFraction converts a number to a precise fraction, and asFloat converts a number to a float.
We can use one of these subclasses by calling FractionalRPNCalculator new or FloatRPNCalculator new. Note that we didn’t need to re-implement new for each; they inherited their new from their superclasses. And, we didn’t need to implement binary:, add, sub, mul, or div, for the same reason. If we needed to specialize one or all of these for these types, we could have overridden them, but all of these types do math the same, so we didn’t need to.
Note that the latest release of GNU Smalltalk has an unfortunate bug in its code to display floating point numbers, and because of this, printing floating point numbers will often fail. This is easily worked around, though, by loading in the float printing code from a later version of GNU Smalltalk. This code is available on the course web site’s assignments tab, named floatfix.st. Load it before your own code, such as gst floatfix.st rpncalc.st. This bug has been fixed in the version of GNU Smalltalk in /u/cs442.
Earlier we said that blocks are similar but not identical to anonymous functions, and the major difference is how they interact with returning. Blocks themselves evaluate to a value—we used this in our binary: method—but this isn’t done with ^, which is how we return from methods. The value of a block is simply the value from the last statement in the block. On the other hand, when you return (with ^) inside of a block, the surrounding method returns, not just the block! For instance, consider the output of this code:
This is particularly useful for making chains of comparisons without getting too deeply nested, or for “switch”-like patterns:
The display and displayNl methods use the displayString method to convert a value to a string. So if we want our RPNCalculator to display its stack when displayNl is called on it, we could extend it with a displayString method:
Note that this only affects display and displayNl, which are not how values are displayed in the interactive REPL. You can override printString for that.
By default, GNU Smalltalk gives stack traces, but nothing else for debugging. However, you can get a debugger (the DebugTools) by loading it into your GNU Smalltalk environment along with your own code, and then you will automatically enter the debugger when there is a problem:
$ gst /u/cs442/students/inst/share/smalltalk/examples/MiniDebugger.st rpncalc.st - Loading package DebugTools GNU Smalltalk ready st> | x | st> x := RPNCalculator new. a RPNCalculator st> x push: 1. 1 st> x push: 0. 0 st> x div. '1 error: The program attempted to divide a number by zero' ZeroDivide(Exception)>>signal (ExcHandling.st:254) SmallInteger(Number)>>zeroDivide (SysExcept.st:1426) SmallInteger>>/ (SmallInt.st:277) optimized [] in RPNCalculator>>div (tmp.st:42) RPNCalculator>>binary: (tmp.st:24) RPNCalculator>>div (tmp.st:42) UndefinedObject>>executeStatements (a String:1) 6 ^self activateHandler: (onDoBlock isNil and: [ self isResumable ]) (debug)
The (debug) prompt acts similarly to gdb: you can go up and down the callgraph, step through code, etc. Use help for a list of commands.
Rather than print, MiniDebugger has i (for “inspect”), which can inspect objects in great detail.
If you want to step through code easily, you’ll have to cause it to break, so that it enters the debugger. This is most easily done by adding the statement self halt to your problematic code.
This course will ask you to use Smalltalk to implement interpreters for (very simple) programming languages. We will not ask you to parse code, and will instead provide parsers for you to use. You are free to ignore our provided parsers and write your own if you’d like, but there’s no reason to do so. Abstract syntax trees will be built manually as Smalltalk objects, and examples given. In general, you should be writing the solution into one .st file, and tests in a separate file loaded afterward, and our input will also work in this way. For example, a simple test case for rpncalc.st might look like this:
And, if that’s in the file test.st, would be run as gst rpncalc.st test.st.
You may use only the libraries built into GNU Smalltalk, floatfix.st, and your own code.
The content described in this document should be sufficient for everything needed in this course. If you feel that more functionality would help you, you can look at the GNU Smalltalk Library Reference (https://www.gnu.org/software/smalltalk/manual-base/html_node/) and User’s Guide (https://www.gnu.org/software/smalltalk/manual/html_node/index.html). If you’re interested in Smalltalk more broadly, you will probably want to look into a more conventional Smalltalk system such as Pharo (https://pharo.org/) or Squeak (https://squeak.org/).
Copyright © 2020–2023 Gregor Richards.
This module is intended for CS442 at University of Waterloo.
Any other use requires permission from the above named copyright holder(s).
© Gregor Richards. | Design by TEMPLATED.