From Wikipedia for FEVERv2
Jump to navigation Jump to search

This article is about the programming language. Smalltalk_sentence_0

For other uses, see Small talk (disambiguation). Smalltalk_sentence_1


ParadigmSmalltalk_header_cell_0_0_0 Object-orientedSmalltalk_cell_0_0_1
Designed bySmalltalk_header_cell_0_1_0 Alan Kay, Dan Ingalls, Adele GoldbergSmalltalk_cell_0_1_1
DeveloperSmalltalk_header_cell_0_2_0 Alan Kay, Dan Ingalls, Adele Goldberg, Ted Kaehler, Diana Merry, Scott Wallace, Peter Deutsch and Xerox PARCSmalltalk_cell_0_2_1
First appearedSmalltalk_header_cell_0_3_0 1972; 48 years ago (1972) (development began in 1969)Smalltalk_cell_0_3_1
Stable releaseSmalltalk_header_cell_0_4_0 Smalltalk-80 version 2
  / 1980; 40 years ago (1980)Smalltalk_cell_0_4_1
Typing disciplineSmalltalk_header_cell_0_5_0 Strong, dynamicSmalltalk_cell_0_5_1
OSSmalltalk_header_cell_0_6_0 Cross-platform (multi-platform)Smalltalk_cell_0_6_1
Major implementationsSmalltalk_header_cell_0_7_0
Influenced bySmalltalk_header_cell_0_8_0

Smalltalk is an object-oriented, dynamically typed reflective programming language. Smalltalk_sentence_2

Smalltalk was created as the language underpinning the "new world" of computing exemplified by "human–computer symbiosis". Smalltalk_sentence_3

It was designed and created in part for educational use, specifically for constructionist learning, at the Learning Research Group (LRG) of Xerox PARC by Alan Kay, Dan Ingalls, Adele Goldberg, Ted Kaehler, Diana Merry, Scott Wallace, and others during the 1970s. Smalltalk_sentence_4

The language was first generally released as Smalltalk-80. Smalltalk_sentence_5

Smalltalk-like languages are in active development and have gathered loyal communities of users around them. Smalltalk_sentence_6

ANSI Smalltalk was ratified in 1998 and represents the standard version of Smalltalk. Smalltalk_sentence_7

Smalltalk took second place for "most loved programming language" in the Stack Overflow Developer Survey in 2017, but it was not among the 26 most loved programming languages of the 2018 survey. Smalltalk_sentence_8

History Smalltalk_section_0

There are a large number of Smalltalk variants. Smalltalk_sentence_9

The unqualified word Smalltalk is often used to indicate the Smalltalk-80 language, the first version to be made publicly available and created in 1980. Smalltalk_sentence_10

The first hardware-environments which run the Smalltalk VMs were Xerox Alto computers. Smalltalk_sentence_11

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. Smalltalk_sentence_12

The first version, termed Smalltalk-71, 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". Smalltalk_sentence_13

A later variant used for research work is now termed Smalltalk-72 and influenced the development of the Actor model. Smalltalk_sentence_14

Its syntax and execution model were very different from modern Smalltalk variants. Smalltalk_sentence_15

After significant revisions which froze some aspects of execution semantics to gain performance (by adopting a Simula-like class inheritance model of execution), Smalltalk-76 was created. Smalltalk_sentence_16

This system had a development environment featuring most of the now familiar tools, including a class library code browser/editor. Smalltalk_sentence_17

Smalltalk-80 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). Smalltalk_sentence_18

Smalltalk-80 was the first language variant made available outside of PARC, first as Smalltalk-80 Version 1, given to a small number of firms (Hewlett-Packard, Apple Computer, Tektronix, and Digital Equipment Corporation (DEC)) and universities (UC Berkeley) for peer review and implementing on their platforms. Smalltalk_sentence_19

Later (in 1983) a general availability implementation, named Smalltalk-80 Version 2, was released as an image (platform-independent file with object definitions) and a virtual machine specification. Smalltalk_sentence_20

ANSI Smalltalk has been the standard language reference since 1998. Smalltalk_sentence_21

Two of the currently popular Smalltalk implementation variants are descendants of those original Smalltalk-80 images. Smalltalk_sentence_22

Squeak is an open source implementation derived from Smalltalk-80 Version 1 by way of Apple Smalltalk. Smalltalk_sentence_23

VisualWorks is derived from Smalltalk-80 version 2 by way of Smalltalk-80 2.5 and ObjectWorks (both products of ParcPlace Systems, a Xerox PARC spin-off company formed to bring Smalltalk to the market). Smalltalk_sentence_24

As an interesting link between generations, in 2001 Vassili Bykov implemented Hobbes, a virtual machine running Smalltalk-80 inside VisualWorks. Smalltalk_sentence_25

(Dan Ingalls later ported Hobbes to Squeak.) Smalltalk_sentence_26

During the late 1980s to mid-1990s, Smalltalk environments—including support, training and add-ons—were sold by two competing organizations: ParcPlace Systems and Digitalk, both California based. Smalltalk_sentence_27

ParcPlace Systems tended to focus on the Unix/Sun microsystems market, while Digitalk focused on Intel-based PCs running Microsoft Windows or IBM's OS/2. Smalltalk_sentence_28

Both firms struggled to take Smalltalk mainstream due to Smalltalk's substantial memory needs, limited run-time performance, and initial lack of supported connectivity to SQL-based relational database servers. Smalltalk_sentence_29

While the high price of ParcPlace Smalltalk limited its market penetration to mid-sized and large commercial organizations, the Digitalk products initially tried to reach a wider audience with a lower price. Smalltalk_sentence_30

IBM initially supported the Digitalk product, but then entered the market with a Smalltalk product in 1995 called VisualAge/Smalltalk. Smalltalk_sentence_31

Easel introduced Enfin at this time on Windows and OS/2. Smalltalk_sentence_32

Enfin became far more popular in Europe, as IBM introduced it into IT shops before their development of IBM Smalltalk (later VisualAge). Smalltalk_sentence_33

Enfin was later acquired by Cincom Systems, and is now sold under the name ObjectStudio, and is part of the Cincom Smalltalk product suite. Smalltalk_sentence_34

In 1995, ParcPlace and Digitalk merged into ParcPlace-Digitalk 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. Smalltalk_sentence_35

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. Smalltalk_sentence_36

In 1999, Seagull Software acquired the ObjectShare Java development lab (including the original Smalltalk/V 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. Smalltalk_sentence_37

VisualWorks was sold to Cincom and is now part of Cincom Smalltalk. Smalltalk_sentence_38

Cincom has backed Smalltalk strongly, releasing multiple new versions of VisualWorks and ObjectStudio each year since 1999. Smalltalk_sentence_39

Cincom, GemTalk, and Instantiations, continue to sell Smalltalk environments. Smalltalk_sentence_40

IBM has 'end of life'd VisualAge Smalltalk having in the late 1990s decided to back Java instead and it is, as of 2005, supported by Instantiations, Inc. who renamed the product VA Smalltalk (VAST Platform) and continue to release new versions yearly. Smalltalk_sentence_41

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. Smalltalk_sentence_42

GNU Smalltalk is a free software implementation of a derivative of Smalltalk-80 from the GNU project. Smalltalk_sentence_43

Pharo Smalltalk is a fork of Squeak oriented toward research and use in commercial environments. Smalltalk_sentence_44

A significant development, that has spread across all Smalltalk environments as of 2016, is the increasing usage of two web frameworks, Seaside and AIDA/Web, to simplify the building of complex web applications. Smalltalk_sentence_45

Seaside has seen considerable market interest with Cincom, Gemstone, and Instantiations incorporating and extending it. Smalltalk_sentence_46

Influences Smalltalk_section_1

Smalltalk was one of many object-oriented programming languages based on Simula. Smalltalk_sentence_47

Smalltalk is also one of the most influential programming languages. Smalltalk_sentence_48

Virtually all of the object-oriented languages that came after—Flavors, CLOS, Objective-C, Java, Python, Ruby, and many others—were influenced by Smalltalk. Smalltalk_sentence_49

Smalltalk was also one of the most popular languages with the Agile Methods, Rapid Prototyping, and Software Patterns communities. Smalltalk_sentence_50

The highly productive environment provided by Smalltalk platforms made them ideal for rapid, iterative development. Smalltalk_sentence_51

Smalltalk emerged from a larger program of ARPA funded research that in many ways defined the modern world of computing. Smalltalk_sentence_52

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_sentence_53

Alan Kay (one of the inventors of Smalltalk) also described a tablet computer he called the Dynabook which resembles modern tablet computers like the iPad. Smalltalk_sentence_54

Smalltalk environments were often the first to develop what are now common object-oriented software design patterns. Smalltalk_sentence_55

One of the most popular is the model–view–controller (MVC) pattern for user interface design. Smalltalk_sentence_56

The MVC pattern enables developers to have multiple consistent views of the same underlying data. Smalltalk_sentence_57

It's ideal for software development environments, where there are various views (e.g., entity-relation, dataflow, object model, etc.) of the same underlying specification. Smalltalk_sentence_58

Also, for simulations or games where the underlying model may be viewed from various angles and levels of abstraction. Smalltalk_sentence_59

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. Smalltalk_sentence_60

The powerful built-in 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. Smalltalk_sentence_61

Object-oriented programming Smalltalk_section_2

Main article: Object-oriented programming Smalltalk_sentence_62

As in other object-oriented languages, the central concept in Smalltalk-80 (but not in Smalltalk-72) is that of an object. Smalltalk_sentence_63

An object is always an instance of a class. Smalltalk_sentence_64

Classes are "blueprints" that describe the properties and behavior of their instances. Smalltalk_sentence_65

For example, a GUI's window class might declare that windows have properties such as the label, the position and whether the window is visible or not. Smalltalk_sentence_66

The class might also declare that instances support operations such as opening, closing, moving and hiding. Smalltalk_sentence_67

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. Smalltalk_sentence_68

A Smalltalk object can do exactly three things: Smalltalk_sentence_69


  1. Hold state (references to other objects).Smalltalk_item_0_0
  2. Receive a message from itself or another object.Smalltalk_item_0_1
  3. In the course of processing a message, send messages to itself or another object.Smalltalk_item_0_2

The state an object holds is always private to that object. Smalltalk_sentence_70

Other objects can query or change that state only by sending requests (messages) to the object to do so. Smalltalk_sentence_71

Any message can be sent to any object: when a message is received, the receiver determines whether that message is appropriate. Smalltalk_sentence_72

Alan Kay has commented that despite the attention given to objects, messaging is the most important concept in Smalltalk: "The big idea is 'messaging'—that is what the kernel of Smalltalk/Squeak is all about (and it's something that was never quite completed in our Xerox PARC phase)." Smalltalk_sentence_73

Unlike most other languages, Smalltalk objects can be modified while the system is running. Smalltalk_sentence_74

Live coding and applying fixes ‘on-the-fly’ is a dominant programming methodology for Smalltalk and is one of the main reasons for its efficiency. Smalltalk_sentence_75

Smalltalk is a "pure" object-oriented programming language, meaning that, unlike C++ and Java, there is no difference between values which are objects and values which are primitive types. Smalltalk_sentence_76

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. Smalltalk_sentence_77

A programmer can change or extend (through subclassing) the classes that implement primitive values, so that new behavior can be defined for their instances—for example, to implement new control structures—or even so that their existing behavior will be changed. Smalltalk_sentence_78

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. Smalltalk_sentence_79

Since all values are objects, classes are also objects. Smalltalk_sentence_80

Each class is an instance of the metaclass of that class. Smalltalk_sentence_81

Metaclasses in turn are also objects, and are all instances of a class called Metaclass. Smalltalk_sentence_82

Code blocks—Smalltalk's way of expressing anonymous functions—are also objects. Smalltalk_sentence_83

Reflection Smalltalk_section_3

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. Smalltalk_sentence_84

Reflection is a feature of dynamic, interactive languages such as Smalltalk and Lisp. Smalltalk_sentence_85

Interactive programs with reflection (either interpreted or compiled) maintain the state of all in-memory objects, including the code object itself, which are generated during parsing/compilation and are programmatically accessible and modifiable. Smalltalk_sentence_86

Reflection is also a feature of having a meta-model as Smalltalk does. Smalltalk_sentence_87

The meta-model is the model that describes the language, and developers can use the meta-model 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 (e.g., all instances of the Method class in the meta-model). Smalltalk_sentence_88

Smalltalk-80 is a totally reflective system, implemented in Smalltalk-80. Smalltalk_sentence_89

Smalltalk-80 provides both structural and computational reflection. Smalltalk_sentence_90

Smalltalk is a structurally reflective system which structure is defined by Smalltalk-80 objects. Smalltalk_sentence_91

The classes and methods that define the system are also objects and fully part of the system that they help define. Smalltalk_sentence_92

The Smalltalk compiler compiles textual source code into method objects, typically instances of CompiledMethod. Smalltalk_sentence_93

These get added to classes by storing them in a class's method dictionary. Smalltalk_sentence_94

The part of the class hierarchy that defines classes can add new classes to the system. Smalltalk_sentence_95

The system is extended by running Smalltalk-80 code that creates or defines classes and methods. Smalltalk_sentence_96

In this way a Smalltalk-80 system is a "living" system, carrying around the ability to extend itself at run time. Smalltalk_sentence_97

Since the classes are objects, they can be asked questions such as "what methods do you implement?" Smalltalk_sentence_98

or "what fields/slots/instance variables do you define?". Smalltalk_sentence_99

So objects can easily be inspected, copied, (de)serialized and so on with generic code that applies to any object in the system. Smalltalk_sentence_100

Smalltalk-80 also provides computational reflection, the ability to observe the computational state of the system. Smalltalk_sentence_101

In languages derived from the original Smalltalk-80 the current activation of a method is accessible as an object named via a pseudo-variable (one of the six reserved words), thisContext. Smalltalk_sentence_102

By sending messages to thisContext a method activation can ask questions like "who sent this message to me". Smalltalk_sentence_103

These facilities make it possible to implement co-routines or Prolog-like back-tracking without modifying the virtual machine. Smalltalk_sentence_104

The exception system is implemented using this facility. Smalltalk_sentence_105

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 Browser's back button by storing continuations for each edited page and switching between them as the user navigates a web site. Smalltalk_sentence_106

Programming the web server using Seaside can then be done using a more conventional programming style. Smalltalk_sentence_107

An example of how Smalltalk can use reflection is the mechanism for handling errors. Smalltalk_sentence_108

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. Smalltalk_sentence_109

The message (another object, an instance of Message) contains the selector of the message and an Array of its arguments. Smalltalk_sentence_110

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. Smalltalk_sentence_111

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 Smalltalk-80's reflective facilities. Smalltalk_sentence_112

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. Smalltalk_sentence_113

Such instances are called transparent proxies. Smalltalk_sentence_114

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. Smalltalk_sentence_115

The design of distributed Smalltalk influenced such systems as CORBA. Smalltalk_sentence_116

Syntax Smalltalk_section_4

Control structures Smalltalk_section_5

Control structures do not have special syntax in Smalltalk. Smalltalk_sentence_117

They are instead implemented as messages sent to objects. Smalltalk_sentence_118

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. Smalltalk_sentence_119

The following code demonstrates this: Smalltalk_sentence_120

Blocks are also used to implement user-defined control structures, enumerators, visitors, exception handling, pluggable behavior and many other patterns. Smalltalk_sentence_121

For example: Smalltalk_sentence_122

In the last line, the string is sent the message select: with an argument that is a code block literal. Smalltalk_sentence_123

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. Smalltalk_sentence_124

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. Smalltalk_sentence_125

When evaluated (by being sent the message "value: each"), the selection block (referenced by the parameter "aBlock", and defined by the block literal "[:aCharacter | aCharacter isVowel]"), answers a boolean, which is then sent "ifTrue:". Smalltalk_sentence_126

If the boolean is the object true, the character is added to a string to be returned. Smalltalk_sentence_127

Because the "select:" method is defined in the abstract class Collection, it can also be used like this: Smalltalk_sentence_128

The exception handling mechanism uses blocks as handlers (similar to CLOS-style exception handling): Smalltalk_sentence_129

The exception handler's "ex" argument provides access to the state of the suspended operation (stack frame, line-number, 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"). Smalltalk_sentence_130

Classes Smalltalk_section_6

This is a stock class definition: Smalltalk_sentence_131

Often, most of this definition will be filled in by the environment. Smalltalk_sentence_132

Notice that this is a message to the Object class to create a subclass called MessagePublisher. Smalltalk_sentence_133

In other words: classes are first-class objects in Smalltalk which can receive messages just like any other object and can be created dynamically at execution time. Smalltalk_sentence_134

Methods Smalltalk_section_7

When an object receives a message, a method matching the message name is invoked. Smalltalk_sentence_135

The following code defines a method publish, and so defines what will happen when this object receives the 'publish' message. Smalltalk_sentence_136

The following method demonstrates receiving multiple arguments and returning a value: Smalltalk_sentence_137

The method's name is #quadMultiply:and:. Smalltalk_sentence_138

The return value is specified with the ^ operator. Smalltalk_sentence_139

Note that objects are responsible for determining dynamically at runtime which method to execute in response to a message—while in many languages this may be (sometimes, or even always) determined statically at compile time. Smalltalk_sentence_140

Instantiating classes Smalltalk_section_8

The following code: Smalltalk_sentence_141

creates (and returns) a new instance of the MessagePublisher class. Smalltalk_sentence_142

This is typically assigned to a variable: Smalltalk_sentence_143

However, it is also possible to send a message to a temporary, anonymous object: Smalltalk_sentence_144

Hello World example Smalltalk_section_9

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. Smalltalk_sentence_145

For Smalltalk, the program is extremely simple to write. Smalltalk_sentence_146

The following code, the message "show:" is sent to the object "Transcript" with the String literal 'Hello, world!' Smalltalk_sentence_147

as its argument. Smalltalk_sentence_148

Invocation of the "show:" method causes the characters of its argument (the String literal 'Hello, world!') Smalltalk_sentence_149

to be displayed in the transcript ("terminal") window. Smalltalk_sentence_150

Note that a Transcript window would need to be open in order to see the results of this example. Smalltalk_sentence_151

Image-based persistence Smalltalk_section_10

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). Smalltalk_sentence_152

They load program code when a program starts, and any prior program state must be recreated explicitly from configuration files or other data sources. Smalltalk_sentence_153

Any settings the program (and programmer) does not explicitly save must be set up again for each restart. Smalltalk_sentence_154

A traditional program also loses much useful document information each time a program saves a file, quits, and reloads. Smalltalk_sentence_155

This loses details such as undo history or cursor position. Smalltalk_sentence_156

Image based systems don't force losing all that just because a computer is turned off, or an OS updates. Smalltalk_sentence_157

Many Smalltalk systems, however, do not differentiate between program data (objects) and code (classes). Smalltalk_sentence_158

In fact, classes are objects. Smalltalk_sentence_159

Thus, most Smalltalk systems store the entire program state (including both Class and non-Class objects) in an image file. Smalltalk_sentence_160

The image can then be loaded by the Smalltalk virtual machine to restore a Smalltalk-like system to a prior state. Smalltalk_sentence_161

This was inspired by FLEX, a language created by Alan Kay and described in his M.Sc. Smalltalk_sentence_162

thesis. Smalltalk_sentence_163

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. Smalltalk_sentence_164

Other languages that model application code as a form of data, such as Lisp, often use image-based persistence as well. Smalltalk_sentence_165

This method of persistence is powerful for rapid development because all the development information (e.g. parse trees of the program) is saved which facilitates debugging. Smalltalk_sentence_166

However, it also has serious drawbacks as a true persistence mechanism. Smalltalk_sentence_167

For one thing, developers may often want to hide implementation details and not make them available in a run time environment. Smalltalk_sentence_168

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. Smalltalk_sentence_169

Also, while the persistence mechanism is easy to use, it lacks the true persistence abilities needed for most multi-user systems. Smalltalk_sentence_170

The most obvious is the ability to do transactions with multiple users accessing the same database in parallel. Smalltalk_sentence_171

Level of access Smalltalk_section_11

Everything in Smalltalk-80 is available for modification from within a running program. Smalltalk_sentence_172

This means that, for example, the IDE can be changed in a running system without restarting it. Smalltalk_sentence_173

In some implementations, the syntax of the language or the garbage collection implementation can also be changed on the fly. Smalltalk_sentence_174

Even the statement true become: false is valid in Smalltalk, although executing it is not recommended. Smalltalk_sentence_175

Just-in-time compilation Smalltalk_section_12

Main article: Just-in-time compilation Smalltalk_sentence_176

Smalltalk programs are usually compiled to bytecode, which is then interpreted by a virtual machine or dynamically translated into machine-native code. Smalltalk_sentence_177

List of implementations Smalltalk_section_13

OpenSmaltalk Smalltalk_section_14

OpenSmaltalk VM (OS VM), is a notable implementation of the Smalltalk Runtime environment on which many modern Smalltalk VMs are based or derived from. Smalltalk_sentence_178

OS VM itself is transpiled from a set of Smalltalk source code files (which is called VMMaker) to native C language source code (by using transpiler called Slang), which is in turn compiled against specific platform and architecture of the hardware practically enabling cross-platform execution of the Smalltalk images. Smalltalk_sentence_179

The source code is available on GitHub and distributed under MIT License. Smalltalk_sentence_180

The known derivatives of the OS VM are: Smalltalk_sentence_181


Others Smalltalk_section_15


  • Amber Smalltalk, runs on JavaScript via transpilationSmalltalk_item_2_7
  • Cincom has the following Smalltalk products: ObjectStudio, VisualWorks and WebVelocity.Smalltalk_item_2_8
  • Cuis-Smalltalk, an open source small, clean and appropriable SmalltalkSmalltalk_item_2_9
  • Visual Smalltalk Enterprise, and family, including Smalltalk/VSmalltalk_item_2_10
  • F-ScriptSmalltalk_item_2_11
  • GemTalk Systems, GemStone/SSmalltalk_item_2_12
  • GNU Smalltalk, headless (lacks GUI) implementation of the SmalltalkSmalltalk_item_2_13
  • StepTalk, GNUstep scripting framework uses Smalltalk language on an Objective-C runtimeSmalltalk_item_2_14
  • VisualAge SmalltalkSmalltalk_item_2_15
  • Rosetta Smalltalk, developed by Scott Warren in 1979 and announced as a cartridge for the Exidy Sorcerer computer but never releasedSmalltalk_item_2_16
  • VAST Platform (VA Smalltalk), developed by Instantiations, IncSmalltalk_item_2_17
  • Little SmalltalkSmalltalk_item_2_18
  • Object Arts, Dolphin SmalltalkSmalltalk_item_2_19
  • Object Connect, Smalltalk MT Smalltalk for WindowsSmalltalk_item_2_20
  • Pocket Smalltalk, runs on Palm PilotSmalltalk_item_2_21
  • , an open source Smalltalk based on Java, derived fromSmalltalk_item_2_22
  • eToys, a visual programming system for learningSmalltalk_item_2_23
  • Strongtalk, for Windows, offers optional strong typingSmalltalk_item_2_24

See also Smalltalk_section_16


Credits to the contents of this page go to the authors of the corresponding Wikipedia page: