smalltalk this article is about the programming language for other uses see small talk disambiguation smalltalk is an objectoriented dynamically typed reflective programming language smalltalk was created as the language to underpin the new world of computing exemplified by humancomputer symbiosis it was designed and created in part for educational use more so for constructionist learning at the learning research group lrg of xerox parc by alan kay dan ingalls adele goldberg ted kaehler scott wallace and others during the 1970s the language was first generally released as smalltalk80 smalltalklike languages are in continuing active development and have gathered loyal communities of users around them ansi smalltalk was ratified in 1998 and represents the standard version of smalltalk smalltalk took second place for most loved programming language in the stack overflow developer survey in 2017 history there are a large number of smalltalk variants the unqualified word smalltalk is often used to indicate the smalltalk80 language the first version to be made publicly available and created in 1980 smalltalk was the product of research led by alan kay at xerox palo alto research center parc alan kay designed most of the early smalltalk versions adele goldberg wrote most of the documentation and dan ingalls implemented most of the early versions the first version termed smalltalk71 was created by kay in a few mornings on a bet that a programming language based on the idea of message passing inspired by simula could be implemented in a page of code a later variant used for research work is now termed smalltalk72 and influenced the development of the actor model its syntax and execution model were very different from modern smalltalk variants after significant revisions which froze some aspects of execution semantics to gain performance by adopting a simulalike class inheritance model of execution smalltalk76 was created this system had a development environment featuring most of the now familiar tools including a class library code browsereditor smalltalk80 added metaclasses to help maintain the everything is an object except private instance variables paradigm by associating properties and behavior with individual classes and even primitives such as integer and boolean values for example to support different ways to create instances smalltalk80 was the first language variant made available outside of parc first as smalltalk80 version 1 given to a small number of firms hewlettpackard apple computer tektronix and digital equipment corporation dec and universities uc berkeley for peer review and implementing on their platforms later in 1983 a general availability implementation named smalltalk80 version 2 was released as an image platformindependent file with object definitions and a virtual machine specification ansi smalltalk has been the standard language reference since 1998 two of the currently popular smalltalk implementation variants are descendants of those original smalltalk80 images squeak is an open source implementation derived from smalltalk80 version 1 by way of apple smalltalk visualworks is derived from smalltalk80 version 2 by way of smalltalk80 25 and objectworks both products of parcplace systems a xerox parc spinoff company formed to bring smalltalk to the market as an interesting link between generations in 2001 vassili bykov implemented hobbes a virtual machine running smalltalk80 inside visualworks dan ingalls later ported hobbes to squeak during the late 1980s to mid1990s smalltalk environmentsincluding support training and addonswere sold by two competing organizations parcplace systems and digitalk both california based parcplace systems tended to focus on the unixsun microsystems market while digitalk focused on intelbased pcs running microsoft windows or ibms os2 both firms struggled to take smalltalk mainstream due to smalltalks substantial memory needs limited runtime performance and initial lack of supported connectivity to sqlbased relational database servers while the high price of parcplace smalltalk limited its market penetration to midsized and large commercial organizations the digitalk products initially tried to reach a wider audience with a lower price ibm initially supported the digitalk product but then entered the market with a smalltalk product in 1995 called visualagesmalltalk easel introduced enfin at this time on windows and os2 enfin became far more popular in europe as ibm introduced it into it shops before their development of ibm smalltalk later visualage enfin was later acquired by cincom systems and is now sold under the name objectstudio and is part of the cincom smalltalk product suite in 1995 parcplace and digitalk merged into parcplacedigitalk and then rebranded in 1997 as objectshare located in irvine ca objectshare nasdaq objs was traded publicly until 1999 when it was delisted and dissolved the merged firm never managed to find an effective response to java as to market positioning and by 1997 its owners were looking to sell the business in 1999 seagull software acquired the objectshare java development lab including the original smalltalkv and visual smalltalk development team and still owns visualsmalltalk although worldwide distribution rights for the smalltalk product remained with objectshare who then sold them to cincom visualworks was sold to cincom and is now part of cincom smalltalk cincom has backed smalltalk strongly releasing multiple new versions of visualworks and objectstudio each year since 1999 cincom gemstone and object arts plus other vendors continue to sell smalltalk environments ibm has end of lifed visualage smalltalk having in the late 1990s decided to back java and it is as of 2006 which has renamed the product va smalltalk and released several new versions the open squeak implementation has an active community of developers including many of the original smalltalk community and has recently been used to provide the etoys environment on the olpc project a toolkit for developing collaborative applications croquet project and the open cobalt virtual world application gnu smalltalk is a free software implementation of a derivative of smalltalk80 from the gnu project pharo smalltalk is a fork of squeak oriented toward research and use in commercial environments a significant development that has spread across all smalltalk environments as of 2016 is the increasing usage of two web frameworks seaside and aidaweb to simplify the building of complex web applications seaside has seen considerable market interest with cincom gemstone and instantiations incorporating and extending it influences smalltalk was one of many objectoriented programming languages based on simula communities the highly productive environment provided by smalltalk platforms made them ideal for rapid iterative development smalltalk emerged from a larger program of arpa funded research that in many ways defined the modern world of computing in addition to smalltalk working prototypes of things such as hypertext guis multimedia the mouse telepresence and the internet were developed by arpa researchers in the 1960s smalltalk environments were often the first to develop what are now common objectoriented software design patterns one of the most popular is the modelviewcontroller mvc pattern for user interface design the mvc pattern enables developers to have multiple consistent views of the same underlying data its ideal for software development environments where there are various views eg entityrelation dataflow object model etc of the same underlying specification also for simulations or games where the underlying model may be viewed from various angles and levels of abstraction in addition to the mvc pattern the smalltalk language and environment were highly influential in the history of the graphical user interface gui and the what you see is what you get wysiwyg user interface font editors and desktop metaphors for ui design the powerful builtin debugging and object inspection tools that came with smalltalk environments set the standard for all the integrated development environments starting with lisp machine environments that came after objectoriented programming objectoriented programming as in other objectoriented languages the central concept in smalltalk80 but not in smalltalk72 is that of an object an object is always an instance of a class classes are blueprints that describe the properties and behavior of their instances for example a guis window class might declare that windows have properties such as the label the position and whether the window is visible or not the class might also declare that instances support operations such as opening closing moving and hiding each particular window object would have its own values of those properties and each of them would be able to perform operations defined by its class a smalltalk object can do exactly three things hold state references to other objects receive a message from itself or another object in the course of processing a message send messages to itself or another object the state an object holds is always private to that object other objects can query or change that state only by sending requests messages to the object to do so any message can be sent to any object when a message is received the receiver determines whether that message is appropriate alan kay has commented that despite the attention given to objects messaging is the most important concept in smalltalk the big idea is messagingthat is what the kernel of smalltalksqueak is all about and its something that was never quite completed in our xerox parc phase smalltalk is a pure objectoriented programming language meaning that unlike c and java there is no difference between values which are objects and values which are primitive types in smalltalk primitive values such as integers booleans and characters are also objects in the sense that they are instances of corresponding classes and operations on them are invoked by sending messages a programmer can change or extend through subclassing the classes that implement primitive values so that new behavior can be defined for their instancesfor example to implement new control structuresor even so that their existing behavior will be changed this fact is summarized in the commonly heard phrase in smalltalk everything is an object which may be more accurately expressed as all values are objects as variables are not since all values are objects classes are also objects each class is an instance of the metaclass of that class metaclasses in turn are also objects and are all instances of a class called metaclass code blockssmalltalks way of expressing anonymous functionsare also objects reflection reflection is a term that computer scientists apply to software programs that have the ability to inspect their own structure for example their parse tree or data types of input and output parameters reflection was first primarily a feature of interpreted languages such as smalltalk and lisp statements being interpreted means that the programs have access to information created as they were parsed and can often even modify their own structure reflection is also a feature of having a metamodel as smalltalk does the metamodel is the model that describes the language and developers can use the metamodel to do things like walk through examine and modify the parse tree of an object or find all the instances of a certain kind of structure eg all instances of the method class in the metamodel smalltalk80 is a totally reflective system implemented in smalltalk80 smalltalk80 provides both structural and computational reflection smalltalk is a structurally reflective system which structure is defined by smalltalk80 objects the classes and methods that define the system are also objects and fully part of the system that they help define the smalltalk compiler compiles textual source code into method objects typically instances of compiledmethod these get added to classes by storing them in a classs method dictionary the part of the class hierarchy that defines classes can add new classes to the system the system is extended by running smalltalk80 code that creates or defines classes and methods in this way a smalltalk80 system is a living system carrying around the ability to extend itself at run time since the classes are objects they can be asked questions such as what methods do you implement or what fieldsslotsinstance variables do you define so objects can easily be inspected copied deserialized and so on with generic code that applies to any object in the system smalltalk80 also provides computational reflection the ability to observe the computational state of the system in languages derived from the original smalltalk80 the current activation of a method is accessible as an object named via a pseudovariable one of the six reserved words thiscontext by sending messages to thiscontext a method activation can ask questions like who sent this message to me these facilities make it possible to implement coroutines or prologlike backtracking without modifying the virtual machine the exception system is implemented using this facility one of the more interesting uses of this is in the seaside web framework which relieves the programmer of dealing with the complexity of a web browsers back button by storing continuations for each edited page and switching between them as the user navigates a web site programming the web server using seaside can then be done using a more conventional programming style an example of how smalltalk can use reflection is the mechanism for handling errors when an object is sent a message that it does not implement the virtual machine sends the object the doesnotunderstand message with a reification of the message as an argument the message another object an instance of message contains the selector of the message and an array of its arguments in an interactive smalltalk system the default implementation of doesnotunderstand is one that opens an error window a notifier reporting the error to the user through this and the reflective facilities the user can examine the context in which the error occurred redefine the offending code and continue all within the system using smalltalk80s reflective facilities by creating a class that understands implements only doesnotunderstand one can create an instance that can intercept any message sent to it via its doesnotunderstand method such instances are called transparent proxies such proxies can then be used to implement a number of facilities such as distributed smalltalk where messages are exchanged between multiple smalltalk systems database interfaces where objects are transparently faulted out of a database promises etc the design of distributed smalltalk influenced such systems as corba syntax smalltalk80 syntax is rather minimalist based on only a handful of declarations and reserved words in fact only six keywords are reserved in smalltalk true false nil self super and thiscontext these are properly termed pseudovariables identifiers that follow the rules for variable identifiers but denote bindings that a programmer cannot change the true false and nil pseudovariables are singleton instances self and super refer to the receiver of a message within a method activated in response to that message but sends to super are looked up in the superclass of the methods defining class rather than the class of the receiver which allows methods in subclasses to invoke methods of the same name in superclasses thiscontext refers to the current activation record the only builtin language constructs are message sends assignment method return and literal syntax for some objects from its origins as a language for children of all ages standard smalltalk syntax uses punctuation in a manner more like english than mainstream coding languages the remainder of the language including control structures for conditional evaluation and iteration is implemented on top of the builtin constructs by the standard smalltalk class library for performance reasons implementations may recognize and treat as special some of those messages however this is only an optimization and is not hardwired into the language syntax the adage that smalltalk syntax fits on a postcard refers to a code snippet by ralph johnson demonstrating all the basic standard syntactic elements of methods examplewithnumber x y true false not nil isnil iffalse y self size super size a a a 1 10 do each transcript show each class name show x y literals the following examples illustrate the most common objects which can be written as literal values in smalltalk80 methods numbers the following list illustrates some of the possibilities 42 42 12345 12345e2 2r10010010 16ra000 the last two entries are a binary and a hexadecimal number respectively the number before the r is the radix or base the base does not have to be a power of two for example 36rsmalltalk is a valid number equal to 80738163270632 decimal characters are written by preceding them with a dollar sign a strings are sequences of characters enclosed in single quotes hello world to include a quote in a string escape it using a second quote i said hello world to them double quotes do not need escaping since single quotes delimit a string i said hello world to them two equal strings strings are equal if they contain all the same characters can be different objects residing in different places in memory in addition to strings smalltalk has a class of character sequence objects called symbol symbols are guaranteed to be uniquethere can be no two equal symbols which are different objects because of that symbols are very cheap to compare and are often used for language artifacts such as message selectors see below symbols are written as followed by a string literal for example foo if the sequence does not include whitespace or punctuation characters this can also be written as foo arrays 1 2 3 4 defines an array of four integers many implementations support the following literal syntax for bytearrays defines a bytearray of four integers and last but not least blocks anonymous function literals blocks are explained in detail further in the text many smalltalk dialects implement additional syntaxes for other objects but the ones above are the essentials supported by all variable declarations the two kinds of variables commonly used in smalltalk are instance variables and temporary variables other variables and related terminology depend on the particular implementation for example visualworks has class shared variables and namespace shared variables while squeak and many other implementations have class variables pool variables and global variables temporary variable declarations in smalltalk are variables declared inside a method see below they are declared at the top of the method as names separated by spaces and enclosed by vertical bars for example index declares a temporary variable named index which contains initially the value nil multiple variables may be declared within one set of bars index vowels declares two variables index and vowels all variables are initialized variables are initialized to nil except the indexed variables of strings which are initialized to the null character or bytearrays which are initialized to 0 assignment a variable is assigned a value via the syntax so vowels aeiou assigns the string aeiou to the formerly declared vowels variable the string is an object a sequence of characters between single quotes is the syntax for literal strings created by the compiler at compile time in the original parc place image the glyph of the underscore character appeared as a leftfacing arrow like in the 1963 version of the ascii code smalltalk originally accepted this leftarrow as the only assignment operator some modern code still contains what appear to be underscores acting as assignments hearkening back to this original usage most modern smalltalk implementations accept either the underscore or the colonequals syntax messages the message is the most fundamental language construct in smalltalk even control structures are implemented as message sends smalltalk adopts by default a synchronous single dynamic message dispatch strategy as contrasted to the asynchronous multiple dispatch strategy adopted by some other objectoriented languages the following example sends the message factorial to number 42 42 factorial in this situation 42 is called the message receiver while factorial is the message selector the receiver responds to the message by returning a value presumably in this case the factorial of 42 among other things the result of the message can be assigned to a variable aratherbignumber 42 factorial factorial above is what is called a unary message because only one object the receiver is involved messages can carry additional objects as arguments as follows 2 raisedto 4 in this expression two objects are involved 2 as the receiver and 4 as the message argument the message result or in smalltalk parlance the answer is supposed to be 16 such messages are called keyword messages a message can have more arguments using the following syntax hello world indexof o startingat 6 which answers the index of character o in the receiver string starting the search from index 6 the selector of this message is indexofstartingat consisting of two pieces or keywords such interleaving of keywords and arguments is meant to improve readability of code since arguments are explained by their preceding keywords for example an expression to create a rectangle using a c or javalike syntax might be written as new rectangle100 200 its unclear which argument is which by contrast in smalltalk this code would be written as rectangle width 100 height 200 the receiver in this case is rectangle a class and the answer will be a new instance of the class with the specified width and height finally most of the special nonalphabetic characters can be used as what are called binary messages these allow mathematical and logical operators to be written in their traditional form 3 4 which sends the message to the receiver 3 with 4 passed as the argument the answer of which will be 7 similarly 3 4 is the message sent to 3 with argument 4 the answer of which will be false notice that the smalltalk80 language itself does not imply the meaning of those operators the outcome of the above is only defined by how the receiver of the message in this case a number instance responds to messages and a side effect of this mechanism is operator overloading a message can also be understood by other objects allowing the use of expressions of the form a b to compare them expressions an expression can include multiple message sends in this case expressions are parsed according to a simple order of precedence unary messages have the highest precedence followed by binary messages followed by keyword messages for example 3 factorial 4 factorial between 10 and 100 is evaluated as follows 3 receives the message factorial and answers 6 4 receives the message factorial and answers 24 6 receives the message with 24 as the argument and answers 30 30 receives the message betweenand with 10 and 100 as arguments and answers true the answer of the last message sent is the result of the entire expression parentheses can alter the order of evaluation when needed for example 3 factorial 4 factorial between 10 and 100 will change the meaning so that the expression first computes 3 factorial 4 yielding 10 that 10 then receives the second factorial message yielding 3628800 3628800 then receives betweenand answering false note that because the meaning of binary messages is not hardwired into smalltalk80 syntax all of them are considered to have equal precedence and are evaluated simply from left to right because of this the meaning of smalltalk expressions using binary messages can be different from their traditional interpretation 3 4 5 is evaluated as 3 4 5 producing 35 to obtain the expected answer of 23 parentheses must be used to explicitly define the order of operations 3 4 5 unary messages can be chained by writing them one after another 3 factorial factorial log which sends factorial to 3 then factorial to the result 6 then log to the result 720 producing the result 285733 a series of expressions can be written as in the following hypothetical example each separated by a period this example first creates a new instance of class window stores it in a variable and then sends two messages to it window window window new window label hello window open if a series of messages are sent to the same receiver as in the example above they can also be written as a cascade with individual messages separated by semicolons window new label hello open this rewrite of the earlier example as a single expression avoids the need to store the new window in a temporary variable according to the usual precedence rules the unary message new is sent first and then label and open are sent to the answer of new code blocks a block of code an anonymous function can be expressed as a literal value which is an object since all values are objects this is achieved with square brackets where params is the list of parameters the code can take this means that the smalltalk code can be understood as f displaystyle f f x x 1 displaystyle fxx1 or expressed in lambda terms as x displaystyle lambda x x 1 displaystyle x1 and value 3 can be evaluated as f 3 3 1 displaystyle f331 or in lambda terms as x x 1 3 4 displaystyle lambda xx13beta rightarrow 4 the resulting block object can form a closure it can access the variables of its enclosing lexical scopes at any time blocks are firstclass objects blocks can be executed by sending them the value message compound variations exist in order to provide parameters to the block eg valuevalue and valuewitharguments the literal representation of blocks was an innovation which on the one hand allowed certain code to be significantly more readable it allowed algorithms involving iteration to be coded in a clear and concise way code that would typically be written with loops in some languages can be written concisely in smalltalk using blocks sometimes in a single line but more importantly blocks allow control structure to be expressed using messages and polymorphism since blocks defer computation and polymorphism can be used to select alternatives so ifthenelse in smalltalk is written and implemented as expr iftrue true methods for evaluation iftrue truealternativeblock iffalse falsealternativeblock truealternativeblock value false methods for evaluation iftrue truealternativeblock iffalse falsealternativeblock falsealternativeblock value positiveamounts allamounts select note that this is related to functional programming wherein patterns of computation here selection are abstracted into higherorder functions for example the message select on a collection is equivalent to the higherorder function filter on an appropriate functor control structures control structures do not have special syntax in smalltalk they are instead implemented as messages sent to objects for example conditional execution is implemented by sending the message iftrue to a boolean object passing as an argument the block of code to be executed if and only if the boolean receiver is true the following code demonstrates this result a b iftrue iffalse blocks are also used to implement userdefined control structures enumerators visitors exception handling pluggable behavior and many other patterns for example astring vowels astring this is a string vowels astring select in the last line the string is sent the message select with an argument that is a code block literal the code block literal will be used as a predicate function that should answer true if and only if an element of the string should be included in the collection of characters that satisfy the test represented by the code block that is the argument to the select message a string object responds to the select message by iterating through its members by sending itself the message do evaluating the selection block ablock once with each character it contains as the argument when evaluated by being sent the message value each the selection block referenced by the parameter ablock and defined by the block literal answers a boolean which is then sent iftrue if the boolean is the object true the character is added to a string to be returned because the select method is defined in the abstract class collection it can also be used like this rectangles apoint collisions rectangles orderedcollection with rectangle left 0 right 10 top 100 bottom 200 with rectangle left 10 right 10 top 110 bottom 210 apoint point x 20 y 20 collisions rectangles select the exception handling mechanism uses blocks as handlers similar to closstyle exception handling some operation onerror doex handlercode ex return the exception handlers ex argument provides access to the state of the suspended operation stack frame linenumber receiver and arguments etc and is also used to control how the computation is to proceed by sending one of ex proceed ex reject ex restart or ex return classes this is a stock class definition object subclass messagepublisher instancevariablenames classvariablenames pooldictionaries category smalltalk examples often most of this definition will be filled in by the environment notice that this is a message to the object class to create a subclass called messagepublisher in other words classes are firstclass objects in smalltalk which can receive messages just like any other object and can be created dynamically at execution time methods when an object receives a message a method matching the message name is invoked the following code defines a method publish and so defines what will happen when this object receives the publish message publish transcript show hello world the following method demonstrates receiving multiple arguments and returning a value quadmultiply i1 and i2 this method multiplies the given numbers by each other and the result by 4 mul mul i1 i2 mul 4 the methods name is quadmultiplyand the return value is specified with the operator note that objects are responsible for determining dynamically at runtime which method to execute in response to a messagewhile in many languages this may be sometimes or even always determined statically at compile time instantiating classes the following code messagepublisher new creates and returns a new instance of the messagepublisher class this is typically assigned to a variable publisher messagepublisher new however it is also possible to send a message to a temporary anonymous object messagepublisher new publish hello world example the hello world program is used by virtually all texts to new programming languages as the first program learned to show the most basic syntax and environment of the language for smalltalk the program is extremely simple to write the following code the message show is sent to the object transcript with the string literal hello world as its argument invocation of the show method causes the characters of its argument the string literal hello world to be displayed in the transcript terminal window transcript show hello world note that a transcript window would need to be open in order to see the results of this example imagebased persistence most popular programming systems separate static program code in the form of class definitions functions or procedures from dynamic or run time program state such as objects or other forms of program data they load program code when a program starts and any prior program state must be recreated explicitly from configuration files or other data sources any settings the program and programmer does not explicitly save must be set up again for each restart a traditional program also loses much useful document information each time a program saves a file quits and reloads this loses details such as undo history or cursor position image based systems dont force losing all that just because a computer is turned off or an os updates many smalltalk systems however do not differentiate between program data objects and code classes in fact classes are objects thus most smalltalk systems store the entire program state including both class and nonclass objects in an image file the image can then be loaded by the smalltalk virtual machine to restore a smalltalklike system to a prior state smalltalk images are similar to restartable core dumps and can provide the same functionality as core dumps such as delayed or remote debugging with full access to the program state at the time of error other languages that model application code as a form of data such as lisp often use imagebased persistence as well this method of persistence is powerful for rapid development because all the development information eg parse trees of the program is saved which facilitates debugging however it also has serious drawbacks as a true persistence mechanism for one thing developers may often want to hide implementation details and not make them available in a run time environment for reasons of legality and maintenance allowing anyone to modify a program at run time inevitably introduces complexity and potential errors that would not be possible with a compiled system that exposes no source code in the run time environment also while the persistence mechanism is easy to use it lacks the true persistence abilities needed for most multiuser systems the most obvious is the ability to do transactions with multiple users accessing the same database in parallel level of access everything in smalltalk80 is available for modification from within a running program this means that for example the ide can be changed in a running system without restarting it in some implementations the syntax of the language or the garbage collection implementation can also be changed on the fly even the statement true become false is valid in smalltalk although executing it is not recommended justintime compilation justintime compilation smalltalk programs are usually compiled to bytecode which is then interpreted by a virtual machine or dynamically translated into machinenative code list of implementations amber smalltalk runs on javascript athena smalltalk scripting engine for java 16 bistro cincom has the following smalltalk products objectstudio visualworks and webvelocity visual smalltalk enterprise and family including smalltalkv cuis smalltalk open source modern smalltalk80 cog jit vm written in squeak smalltalk fscript gemtalk systems gemstones gnu smalltalk toil pragmatic smalltalk for toil a gnustepbased user environment steptalk gnustep scripting framework uses smalltalk language on an objectivec runtime gravel smalltalk runs on a java virtual machine instantiations va smalltalk being the followon to ibm visualage smalltalk visualage smalltalk little smalltalk object arts dolphin smalltalk object connect smalltalk mt smalltalk for windows objectivesmalltalk runs on objectivec runtime with extensions for software architecture lsw visionsmalltalk have partnered with object arts panda smalltalk open source engine written in c has no dependencies except libc pharo smalltalk an opensource crossplatform language cog jit vm written in squeak smalltalk pocket smalltalk runs on palm pilot redline smalltalk runs on a java virtual machine refactory produces smalltalk smalltalk yx smalltalkx squeak open source smalltalk cog jit vm written in squeak smalltalk cogdroid port of nonjit variant of cog vm to android etoys a visual programming system for learning isqueak squeak interpreter port for ios devices iphoneipad jsqueak squeak interpreter written in java potato squeak interpreter written in java a direct derivative of jsqueak roarvm roarvm is a multi and manycore interpreter for squeak and pharo strongtalk for windows offers optional strong typing vista smalltalk calmosoft project for vista smalltalk objectivec glass software bundle distributed data management architecture goldberg adele december 1983 smalltalk80 the interactive programming environment addisonwesley isbn0201113724 goldberg adele kay alan eds march 1976 smalltalk72 instruction manual pdf palo alto california xerox palo alto research center retrieved 20111111 goldberg adele robson david may 1983 smalltalk80 the language and its implementation pdf addisonwesley isbn0201113716 goldberg adele robson david 11 january 1989 smalltalk 80 the language addisonwesley isbn0201136880 kay alan c march 1993 the early history of smalltalk pdf acm sigplan notices acm 28 3 6995 doi101145155360155364 krasner glen ed august 1983 smalltalk80 bits of history words of advice addisonwesley isbn0201116693 nierstrasz oscar ducasse stphane pollet damien black andrew p 20091007 squeak by example kehrsatz switzerland square bracket associates isbn3952334103 nierstrasz oscar ducasse stphane pollet damien black andrew p february 23 2010 pharo by example kehrsatz switzerland square bracket publishing isbn9783952334140 archived from the original on october 21 2009 winston patrick henry september 3 1997 on to smalltalk mit usa addison wesley isbn9780201498271 brauer johannes 2015 programming smalltalk objectorientation from the beginning springer isbn9783658068233 special issue on smalltalk byte mcgrawhill 6 8 august 1981 retrieved 20131018 goldberg adele august 1981 introducing the smalltalk80 system byte mcgrawhill 6 8 retrieved 20131018 ingalls dan august 1981 design principles behind smalltalk byte mcgrawhill 6 8 retrieved 20111111 tesler larry august 1981 the smalltalk environment byte mcgrawhill 6 8 retrieved 20160502 wikibooks has a book on the topic of programmingsmalltalk the world of smalltalk books videos implementations frameworks tools blogs and mailing lists planet smalltalk an aggregator of smalltalk blog posts downloadable books on smalltalk permission obtained to make these books freely available over 25 full texts scanned from print smalltalk at curlie european smalltalk users group esug nonprofit organization with commercial and academic members has various promotion activities including a yearly event since 1993 smalltalk industry council stic promoting smalltalk on behalf of the smalltalk community la fundacion argentina de smalltalk fast organizer of annual smalltalk conference in argentina clubsmalltalk a latin american group to promote smalltalk technology with a website in english gnu smalltalk gnu project squeak free smalltalk ide pharo another free smalltalk ide vtesmalltalk programming languageimplementationsmajor amber dolphin smalltalk gemstones gnu smalltalk pharo smalltalkx squeak visualage smalltalk visualworks dialects fscript little smalltalk newspeak pocket smalltalk self steptalk strongtalk software aidaweb croquet gemstones open cobalt seaside communitypeople lars bak gilad bracha l peter deutsch adele goldberg urs hlzle dan ingalls ted kaehler alan kay diana merry scott wallace developers gemstone cincom systems ibm object arts xerox parc category vteprogramming languages comparison timeline history apl assembly basic c c c cobol fortran go groovy haskell java javascript js kotlin lisp lua objectivec pascal perl php python ruby rust shell smalltalk swift visual basic net vbnet more category lists alphabetical categorical generational nonenglishbased authority control bnf cb12158691c data lccn sh87003115 sudoc 030104092 