Wikipedia - User contributions [en]

VisualAge

2020-03-11T22:02:15Z

Mike1turner: /* VisualAge */ Modified the article as per the references.

{{ Infobox Software
| name = VisualAge
| logo =
| screenshot =
| caption =
| collapsible =
| developer = [[IBM]]
| discontinued = yes
| released = {{start date and age|1993|10|12}}
| latest_release_version = 6.0
| latest_release_date = {{Start date and age|2007|04|30}}
| latest_preview_version =
| latest_preview_date =
| operating_system = [[Cross-platform]]
| language = Multilingual
| programming_language = [[Smalltalk]] and later [[Java (programming language)|Java]]
| genre = [[Software development]]
| license = [[Proprietary software|Proprietary]]
| website = {{URL|web.archive.org/web/20110915104218/http://www-01.ibm.com/software/awdtools/vacpp|www-01.ibm.com/software/awdtools/vacpp}}
}}

'''VisualAge''' is a family of computer [[integrated development environment]]s from [[IBM]], which supports multiple [[programming languages]]. VisualAge was first released in October 1993 and was discontinued April 30, 2007 and its web page removed in September 2011.<ref name="FirstVisualAge">{{cite press release|title=VisualAge for OS/2, Version 1.0 |url=http://www-01.ibm.com/common/ssi/rep_ca/5/877/ENUSZP93-0585/ |author=|publisher=IBM|id=ENUSZP93-0585|date=October 12, 1993 |accessdate=March 12, 2018}}</ref><ref>{{citation|title=Software withdrawal: Selected IBM C, VisualAge C++, and XL Fortran programs |url=http://www.ibm.com/common/ssi/rep_ca/0/897/ENUS905-270/ENUS905-270.PDF |publisher=IBM|id=ENUS905-270|date=December 13, 2005 |accessdate=March 12, 2018}}</ref> VisualAge was also marketed as VisualAge Smalltalk, and in 2005, Instantiations, Inc. acquired the worldwide rights to this product. IBM has stated that [[IBM XL C++|XL C/C++]] is the followup product to VisualAge.<ref>{{Cite web|url=http://www-01.ibm.com/software/awdtools/vacpp |title=VisualAge C++|publisher=IBM|accessdate=January 26, 2011 |url-status=dead |archiveurl=https://web.archive.org/web/20110915104218/http://www-01.ibm.com/software/awdtools/vacpp|archivedate=September 15, 2011}}</ref>

==Early history==
VisualAge was born in the IBM development lab in [[Cary, North Carolina]], which was established in 1984 and had responsibility for application [[Programming tool|development tools]]. The EZ-VU dialog manager product, a personal computer derivative of the user interface elements of the [[ISPF]] [[IBM 3270|327x]] product was one of the first products in this family. The lab also had a group which was one of the early adopters of [[object-oriented programming]] technologies within IBM using an internally developed language called ClassC to develop applications with more sophisticated [[graphical user interface]]s which were just starting to be widely available.

Eventually, the availability of usable implementations of [[Smalltalk]] for [[IBM PC]]-AT class machines allowed IBM advanced technology projects to experiment with Smalltalk. At about the same time, visual interface construction tools were coming up on the radar screens. Smalltalk research projects such as InterCons by David N. Smith of IBM, and [[Fabrik (software)|Fabrik]] by a team at Apple led by [[Dan Ingalls]] were building interactive graphical applications built from composition of graphical primitives. Higher level construction of user interfaces was evidenced by other tools such as [[Jean-Marie Hullot]]'s interface builder first done in [[Lisp (programming language)|Lisp]] and then evolved to become the [[Interface Builder]] tool in [[NeXTStep]] and [[Mac OS X]]. Such tools allow for building user interfaces by [[WYSIWYG]] composition of UI widgets which can be "wired" to each other and to application logic written in the system's native object oriented language, or possibly with no coding at all.

The original prototype which led to VisualAge was an attempt "to make something like the [[Interface Builder|NeXT interface builder]]"<ref name="RoundInCircles">{{cite web|url=http://talklikeaduck.denhaven2.com/articles/2008/10/15/will-it-go-round-in-circles |title=Will It Go Round in Circles? (IBM, Smalltalk, and VisualAge) |accessdate=November 1, 2008 |url-status=dead |archiveurl=https://web.archive.org/web/20081019055616/http://talklikeaduck.denhaven2.com/articles/2008/10/15/will-it-go-round-in-circles |archivedate=October 19, 2008}}</ref> within the [[Smalltalk/V]] development environment. By the time VisualAge was released as a product, much more emphasis was placed on visual construction of application logic as well as of the user interface. This emphasis was in part due to the "positioning" for "strategic" reasons of Smalltalk as a generator rather than a language within IBM's [[Systems Application Architecture]].

===VisualAge===
The name "VisualAge" is the result of a contest between the members of the development team. After the initial release of VisualAge/Smalltalk the name VisualAge became a brand of its own and VisualAges were produced for several different combinations of languages and platforms.

These are the overall supported languages, variously available depending on the platform: [[BASIC]], [[COBOL]], [[C (programming language)|C]], [[C++]], [[EGL (programming language)|EGL]], [[Fortran]], [[Java (programming language)|Java]], [[Pacbase]], [[PL/I]], [[IBM RPG]], and [[Smalltalk]].

These are the supported platforms, each of which support different languages: [[AIX]], [[OS/2]], [[i5/OS]] (formerly named [[OS/400]]), [[Linux]], [[Mac OS X]], [[Microsoft Windows]], [[Transaction Processing Facility|TPF]], [[z/VM]], [[z/OS]] (formerly named [[OS/390]], [[MVS]]), and [[z/VSE]].

Most of the members of the VisualAge family were written in Smalltalk no matter which language they supported for development. The IBM implementation of Smalltalk was produced by [[Object Technology International]] which was acquired by IBM and run as a wholly owned subsidiary for several years before being absorbed into the overall IBM organization.

VisualAge for Java is based on an extended Smalltalk [[virtual machine]] which executes both Smalltalk and Java [[byte code]]s. Java natives were actually implemented in Smalltalk.<ref>{{cite web|url=https://web.archive.org/web/20081019055616/http://talklikeaduck.denhaven2.com/articles/2008/10/15/will-it-go-round-in-circles |title=Will It Go Round in Circles? |publisher=denhaven2|accessdate=October 19, 2016}}</ref>

VisualAge Micro Edition, which supports development of embedded Java applications and cross system development, is a reimplementation of the IDE in Java. This version of VisualAge morphed into the [[Eclipse (computing)|Eclipse Framework]].

Various members of the family have been replaced by products in the [[WebSphere]] Studio family of products. By 2005, Smalltalk specialist Instantiations, Inc. had assumed technical support responsibilities and been granted global rights to the IBM VisualAge Smalltalk product line and technology base.<ref>{{cite web|title=VisualAge Smalltalk Transition FAQ |url=http://www.instantiations.com/company/ibm-transition.html |publisher=Instantiations |accessdate=March 12, 2018}}</ref> Instantiations continues to offer the “enhanced product” named VA Smalltalk (VAST Platform).<ref>{{cite web|url=http://www.instantiations.com/products/vasmalltalk/index.html |title=Smalltalk Products Home |publisher=Instantiations|accessdate=May 19, 2009}}</ref><ref>{{cite web|url=http://www.instantiations.com/company/history.html |title=Instantiations History |publisher=Instantiations|accessdate=May 19, 2009}}</ref> The C, C++ and Fortran compiler on AIX, Linux and z/OS are renamed as [[IBM XL C++|XL C/C++]] series.

==Releases==
Applications designed with VisualAge C++ may be portable between target platforms without any code changes needed if VisualAge guidelines were followed. IBM also included additional tools and libraries in instances where portability was not possible without code changes.<ref>{{cite web|title=VisualAge C++ |url=http://www.edm2.com/index.php/VisualAge_C%2B%2B |publisher=EDM/2|accessdate=March 12, 2018}}</ref>

===OS/2 and Windows===
*VisualAge C++ 3.0 (OS/2 and Windows)
*VisualAge C++ 3.5 (Windows 95/NT only)
*C and C++ Compilers for OS/2, AIX and Windows NT Version 3.6
*VisualAge C++ Professional 4.0 (OS/2 and Windows)
*VisualAge Generator Developer V3.1 for OS/2
*VisualAge Generator Server V3.1 for OS/2<ref>{{cite press release|title=IBM VisualAge Generator for OS/2 and Windows NT Version 3.1 Boosts Application Development Productivity |url=http://www-01.ibm.com/common/ssi/rep_ca/0/897/ENUS298-190/ |author=|publisher=IBM|date=June 16, 1998 |id=ENUS298-190 |access-date=March 12, 2018 |url-status=live |archiveurl=https://www-01.ibm.com/common/ssi/cgi-bin/ssialias?htmlfid=897/ENUS298-190&infotype=AN&subtype=CA&appname=skmwww |archivedate=March 12, 2018}}</ref>
*VisualAge for OS/2 1.0 (1993-10-12)<ref name="FirstVisualAge"/>
*VisualAge COBOL for OS/2 1.0 (1994-03-29)<ref>{{cite press release|title=VisualAge for OS/2, Version 1.0 |url=http://www-01.ibm.com/common/ssi/rep_ca/2/877/ENUSZP94-0232/ |author=|publisher=IBM|id=ENUSZP94-0232|date=March 29, 1994 |accessdate=March 12, 2018}}</ref>
*VisualAge for COBOL for OS/2 1.1
*VisualAge for COBOL for OS/2 1.2
*VisualAge for COBOL for OS/2, Version 1 Release 2
*VisualAge COBOL for OS/2 2.0
*VisualAge for COBOL Version 2.1
*VisualAge COBOL 2.2
*VisualAge COBOL Enterprise 3.07 (Windows only)

===OS/400===
*VisualAge C++ for AS/400 V3R6
*VisualAge C++ for AS/400 V3R7
*VisualAge C++ for AS/400 V4R4

===AIX===
*VisualAge C++ Professional for AIX
*VisualAge C++ Professional for AIX, V5.0
*VisualAge C++ Professional for AIX, V6.0

===POWER Linux===
*VisualAge C++ V6.0 for Linux
*VisualAge C++ V6.0 for Linux refresh

==See also==
* [[IBM Cross System Product (CSP)]]: an article which discusses IBM VisualAge Generator
* [[Source Code in Database]]

==References==
===Citations===
{{reflist}}

===Bibliography===
{{refbegin}}
VisualAge - Smalltalk

* IBM Corp., IBM, (1994). “IBM VisualAge (printed paper bound retail hardboard box)”. . IBM Corp. Part Number 14H0969 and lid Part Number 30H2314 Product Number 17H7495 Bar code: 087944096085
* IBM Corp., IBM, (Spring 1995). “Smalltalk resource catalogue”. . IBM Corp. (96 pages) Product Number G325-0813-01 Part Number 30H2238
* IBM Corp., IBM, (October 1994). “Development guide”. 1st edition. (250 pages) Product Number SC34-4495-00 Part Number 14H0295
* IBM Corp., IBM, (October 1994). “Programmer’s reference”. 2nd edition. IBM Corp. (458 pages) Product Number SC34-4493-01 Part Number 14H0297
* IBM Corp., IBM, (October 1994). “IBM Smalltalk”. 2nd edition. IBM Corp. (172 pages) Product Number SC34-4491-01 Part Number 14H0296
* IBM Corp., IBM, (October 1994). “Installation guide booklet”. 2nd edition. IBM Corp. (48 pages) Part Number 14H1071
* IBM Corp., IBM, (October 1994). “Programmer’s guide to building”. 2nd edition. IBM Corp. (149 pages) Product Number SC34-4496-00 Part Number 14H1070
* IBM Corp., IBM, (October 1994). “User’s Guide and Reference”. 2nd edition. IBM Corp. (642 pages) Product Number SC34-4490-01 Part Number 14H0922;

IBM VisualAge for COBOL Standard is “Year 2000 ready” and Requires: Warp Version 4.0 plus FixPak 1 or Windows NT 4.0 plus Service Pack 3

* IBM Corp., IBM, (1997). “IBM VisualAge for COBOL Standard (printed retail card box)”. Version 2.1. IBM Corp. Product Number P4301938 Bar Code: 1264301938000104 Part Number 4301978
* IBM Corp., IBM, (1997). “IBM VisualAge for COBOL Getting Started on Windows Manual”. IBM Corp. (130 pages) Product number GC26-8944-01 Bar Code: GC26-8944-01 Part No. 4301981
* IBM Corp., IBM, (September 1997). “IBM VisualAge for COBOL Getting Started on OS/2 Manual”. IBM Corp. 2nd Edition. (156 pages) Document Number GC26-9051-01
* IBM Corp., IBM, (April 1997). “Resource Catalogue for IBM COBOL Family V 1”. Release 4. (44 pages) Product Number GC26-8488-03 Part Number 4226010
{{refend}}

==External links==
*{{Official website}}
*[https://web.archive.org/web/20041205025652/http://www-306.ibm.com:80/software/awdtools/vaes/ VisualAge Enterprise Suite]
*[http://www.edm2.com/index.php/VisualAge_C%2B%2B VisualAge C++] description from Electronic Developer Magazine for OS/2 (EDM/2)
*[http://c2.com/cgi/wiki?VisualAge Visual Age] description from Portland Pattern Repository
*[http://www.instantiations.com/products/vasmalltalk/index.html VA Smalltalk at Instantiations]
*[http://www.javadude.com/vaj/ VisualAge for Java Tips and Tricks]

{{Smalltalk programming language}}
{{Integrated development environments}}

[[Category:C compilers|VisualAge]]
[[Category:C++ compilers|VisualAge]]
[[Category:Compilers|VisualAge]]
[[Category:Eclipse (software)|VisualAge]]
[[Category:Fortran compilers|VisualAge]]
[[Category:IBM software|VisualAge]]
[[Category:Integrated development environments|VisualAge]]
[[Category:Linux integrated development environments|VisualAge]]
[[Category:MacOS programming tools|VisualAge]]
[[Category:OS/2 software|VisualAge]]
[[Category:Programming tools for Windows|VisualAge]]
[[Category:Smalltalk programming language family]]

Visual Smalltalk Enterprise

2020-03-04T00:20:59Z

Mike1turner: /* People */

{{Infobox software
| name = Visual Smalltalk Enterprise
| screenshot =
| caption =
| author = Digitalk
| developer = Digitalk (1986–1995), Parc Place Systems (1995-1997)
| discontinued = yes
| latest_release_version = VSE v3.2.0 (a.k.a. VSE2000)
| latest_release_date = {{Release date and age|2000|09}}
| latest preview version =
| latest preview date =
| operating system = [[MS-DOS]], [[Windows]], [[OS/2]]
| language = English
| status = Unmaintained
| genre = [[Integrated Development Environment]]
| license = [[Commercial software|Commercial]]
| website = {{URL|cincomsmalltalk.com}}
}}

'''Visual Smalltalk Enterprise''' (VSE) is a [[Smalltalk]] dialect that runs only on Microsoft Windows, and is the last in a long line of Smalltalk implementations first produced by Digitalk and now available through Cincom.

Active development has stopped since late 1997<ref>{{cite web|last1=Hoyer|first1=Henrik|title=Is Cincom slowly killing Visual Smalltalk Enterprice|url=http://forum.world.st/Is-Cincom-slowly-killing-Visual-Smalltalk-Enterprice-td2513847.html|website=SmallTalk forum|accessdate=2015-12-23}}</ref> and VSE is now only available as a version called VSE 2000, and only to licensed users of previous VSE versions.

==History==

VSE has had a complicated history which starts with a product called Digitalk Smalltalk/V that ran from a DOS prompt and provided a windowing environment.

* Smalltalk/V (1986, [[MS-DOS]])
* Smalltalk/V 286 (1988, [[MS-DOS]])
* Smalltalk/V PM (1989, Presentation Manager under [[OS/2]])
* Smalltalk/V Win (1991, [[Windows 3.x]])
* Visual Smalltalk Enterprise (VSE) (1992, [[Windows 3.x]])
* Visual Smalltalk Enterprise 3.0 (1995, [[Windows 95]])

Before Smalltalk/V, the first commercial Smalltalk product from Digitalk was Digitalk Methods released in 1983. The windowing interface was not graphically based - instead it drew its windows using special symbols stored in a character format. Further, it predated the use of a mouse to drive the interface.

There have also been versions of Smalltalk/V for the Apple Macintosh and IBM OS/2 operating systems. A version for OS/2 was also available for VSE.

In July 1995 ParcPlace and Digitalk merged, later renaming the company to ObjectShare, and in 1997 the company announced it was moving away from Smalltalk and focus towards Java.<ref>{{cite web|last1=Levez|first1=Belinda|title=Reconstructed timeline for Visual Smalltalk from Digitalk|url=http://answers.google.com/answers/threadview/id/236072.html|website=Google Answers|accessdate=2016-03-20}}</ref>

== PARTS Workbench ==
Visual Smalltalk Enterprise usually comes with another sub-system called the PARTS Workbench. This system allows the layout of components, which can then be connected using a visual representation of event-message links. Programmers can add scripts to particular components and build nested-components. They can also enhance the functionality of the main VSE Smalltalk system and use that within the PARTS Workbench.

Although the PARTS Workbench allows very easy development of small systems (somewhat after the style of Visual Basic) it is argued that it encourages fragmentary development. The natural style of using this system tends to lead to lots of links and scripts - it is not based around the idea of 'model' (as used in '[[Model–View–Controller]]' approaches common in many Smalltalks as well as in other languages). However, as an 'HCI' for programmers, the PARTS Workbench has many features that are not in modern Smalltalks. It has an immediacy that makes it very good for introductory teaching and for rapidly implementing programs with visual interfaces.

==Copyrights, licensing==

A result of the complex history is that the copyright and licensing situation is unclear and a typical recent VSE development environment is made up of many elements many of which were developed by third parties and sold separately but are now included with the distribution.

The situation with the most recent release (VSE 2000) is:

{| class="wikitable"
|-
! Element
! Copyright Holder
! License
|-
| Virtual machine
| Seagull
| Seagull owns VSE. Cincom has the right to sell it and provide support.<ref>http://groups.google.co.uk/group/comp.lang.smalltalk/msg/2979f8877244937f?hl=en&</ref>
|-
| Base Classes
| Unknown
| Unknown
|-
| ObjectShare Classes
| Cincom
| Includes WindowBuilder, various WidgetKits, GF/ST, etc. As such, Cincom can (almost?) do anything it wants with those products (keeping mind the OEM DLL issues affecting two of the WidgetKits).
|-
| Profile/V
| [[Kent Beck]]
| Open Source, under the CPL 1.0 license (Though donations are appreciated). A performance profiler. Not actually part of the VSE distribution.
|}

==People==
A partial list of people that worked at Digitalk/ParcPlace on VSE:

{| class="wikitable"
|-
! Person
! Comments
|-
| [[George Bosworth]]
| Co-founder of Digitalk and co-creator of Smalltalk/V. Inventor of [[Ephemeron]]s. Worked later on the garbage collector in the Microsoft .Net.
|-
| Jim Anderson
| Co-founder of Digitalk and co-creator of Smalltalk/V.
|-
| [[Mike Teng]]
| Co-founder of Digitalk and co-creator of Smalltalk/V.
|-
| [[Barbara Noparstak]]
| Co-founder of Digitalk.
|-
| [[Lee Breisacher]]
| Early employee of Digitalk and significant contributor to Smalltalk/V Win and PM and VSE.
|-
| [[Allen Wirfs-Brock]]
| Chief scientist at Digitalk-ParcPlace. Currently works for [[Mozilla]].
|-
| [[Eric Clayberg]]
| Creator of [[WindowBuilder]] toolkit. Formerly Vice President of Development at Digitalk-ParcPlace. [http://www.smalltalksystems.com/clayberg/resume.htm]. Formerly Vice President of Product Development at Instantiations [http://www.smalltalksystems.com/clayberg/]. Current board member of Instantiations.
|-
| Stephan B. Wessels
| Digitalk Professional Services, frameworks development. [http://www.preeminent.org/steve/], [http://www.preeminent.org/steve/pages/resume/Smalltalk-experience.html].
|-
| Suzanne Fortman
| Digitalk Marketing. Came back to [[Cincom]] as Smalltalk Program Director.
|-
| Gary Gregory
| Worked on VSE, PARTS, the VM and database interfaces. Now works at [[Seagull Software]] [http://www.seagullsoftware.com].
|-
| Dan Rubel
| Worked on Subpanes/V. Former CTO of Instantiations [https://www.linkedin.com/in/danrubel/]
|-
| Roxie Rochat
| Worked on Subpanes/V. Now works for Stoaks Software.[http://stoaks-software.com/Staff/Roxie/Resume.pdf]
|-
| Bart Weller
| Worked on Subpanes/V.
|-
| Ken Cooper
| Worked on Subpanes/V. Got hired by Microsoft in 1997. [http://www.microsoft.com/presspass/press/1997/jun97/coopet.mspx]
|-
| Ted Peters
| Worked on Subpanes/V. Also got hired by Microsoft in 1997. [http://www.microsoft.com/presspass/press/1997/jun97/coopet.mspx]
|-
| Mike Taylor
| Was Vice President of Professional Services at Digitalk. Formerly CEO and president of Instantiations.[http://www.instantiations.com/company/staff.html] Current board member of Instantiations.
|-
|Tim Rowledge
| Worked on a lot of Smalltalk stuff at ParcPlace Systems Inc. Now works on [[Squeak]].
|}

==External links==
*The VSE Mailing List: [http://www.listserv.dfn.de/archives/vswe-l.html VSWE-L]
*[http://www.seagullsoftware.com/ Seagull Software Systems, Inc.]
*Cincom Page about VSE:[http://www.cincomsmalltalk.com/userblogs/cincom/blogView?content=vse http://www.cincomsmalltalk.com/userblogs/cincom/blogView?content=vse]
*Threads of discussion about copyright and licensing:
**[http://groups.google.co.uk/group/comp.lang.smalltalk/browse_thread/thread/187e48c4b968acf6/2979f8877244937f comp.lang.smalltalk Apr. 2005]
*[http://f.webring.com/t/Smalltalk Smalltalk web ring] Smalltalk products and services.
*[https://vs-kb.apis.de/] Welcome to the Visual Smalltalk Knowledge Base!
*[http://www.smalltalking.net/Goodies/VisualSmalltalk/index.htm] Goodies at [http://www.smalltalking.net] Smalltalking web site.
*[http://www.totallyobjects.com/vsfree.htm] Goodies at [http://www.totallyobjects.com/ Totally Objects].
*[http://360businesstool.com/smalltalk] Goodies at [http://360businesstool.com/ 360 Business Tool].

== References ==
<references/>

[[Category:Smalltalk programming language family]]

Visual Smalltalk Enterprise

2020-03-04T00:14:22Z

Mike1turner: /* People */

{{Infobox software
| name = Visual Smalltalk Enterprise
| screenshot =
| caption =
| author = Digitalk
| developer = Digitalk (1986–1995), Parc Place Systems (1995-1997)
| discontinued = yes
| latest_release_version = VSE v3.2.0 (a.k.a. VSE2000)
| latest_release_date = {{Release date and age|2000|09}}
| latest preview version =
| latest preview date =
| operating system = [[MS-DOS]], [[Windows]], [[OS/2]]
| language = English
| status = Unmaintained
| genre = [[Integrated Development Environment]]
| license = [[Commercial software|Commercial]]
| website = {{URL|cincomsmalltalk.com}}
}}

'''Visual Smalltalk Enterprise''' (VSE) is a [[Smalltalk]] dialect that runs only on Microsoft Windows, and is the last in a long line of Smalltalk implementations first produced by Digitalk and now available through Cincom.

Active development has stopped since late 1997<ref>{{cite web|last1=Hoyer|first1=Henrik|title=Is Cincom slowly killing Visual Smalltalk Enterprice|url=http://forum.world.st/Is-Cincom-slowly-killing-Visual-Smalltalk-Enterprice-td2513847.html|website=SmallTalk forum|accessdate=2015-12-23}}</ref> and VSE is now only available as a version called VSE 2000, and only to licensed users of previous VSE versions.

==History==

VSE has had a complicated history which starts with a product called Digitalk Smalltalk/V that ran from a DOS prompt and provided a windowing environment.

* Smalltalk/V (1986, [[MS-DOS]])
* Smalltalk/V 286 (1988, [[MS-DOS]])
* Smalltalk/V PM (1989, Presentation Manager under [[OS/2]])
* Smalltalk/V Win (1991, [[Windows 3.x]])
* Visual Smalltalk Enterprise (VSE) (1992, [[Windows 3.x]])
* Visual Smalltalk Enterprise 3.0 (1995, [[Windows 95]])

Before Smalltalk/V, the first commercial Smalltalk product from Digitalk was Digitalk Methods released in 1983. The windowing interface was not graphically based - instead it drew its windows using special symbols stored in a character format. Further, it predated the use of a mouse to drive the interface.

There have also been versions of Smalltalk/V for the Apple Macintosh and IBM OS/2 operating systems. A version for OS/2 was also available for VSE.

In July 1995 ParcPlace and Digitalk merged, later renaming the company to ObjectShare, and in 1997 the company announced it was moving away from Smalltalk and focus towards Java.<ref>{{cite web|last1=Levez|first1=Belinda|title=Reconstructed timeline for Visual Smalltalk from Digitalk|url=http://answers.google.com/answers/threadview/id/236072.html|website=Google Answers|accessdate=2016-03-20}}</ref>

== PARTS Workbench ==
Visual Smalltalk Enterprise usually comes with another sub-system called the PARTS Workbench. This system allows the layout of components, which can then be connected using a visual representation of event-message links. Programmers can add scripts to particular components and build nested-components. They can also enhance the functionality of the main VSE Smalltalk system and use that within the PARTS Workbench.

Although the PARTS Workbench allows very easy development of small systems (somewhat after the style of Visual Basic) it is argued that it encourages fragmentary development. The natural style of using this system tends to lead to lots of links and scripts - it is not based around the idea of 'model' (as used in '[[Model–View–Controller]]' approaches common in many Smalltalks as well as in other languages). However, as an 'HCI' for programmers, the PARTS Workbench has many features that are not in modern Smalltalks. It has an immediacy that makes it very good for introductory teaching and for rapidly implementing programs with visual interfaces.

==Copyrights, licensing==

A result of the complex history is that the copyright and licensing situation is unclear and a typical recent VSE development environment is made up of many elements many of which were developed by third parties and sold separately but are now included with the distribution.

The situation with the most recent release (VSE 2000) is:

{| class="wikitable"
|-
! Element
! Copyright Holder
! License
|-
| Virtual machine
| Seagull
| Seagull owns VSE. Cincom has the right to sell it and provide support.<ref>http://groups.google.co.uk/group/comp.lang.smalltalk/msg/2979f8877244937f?hl=en&</ref>
|-
| Base Classes
| Unknown
| Unknown
|-
| ObjectShare Classes
| Cincom
| Includes WindowBuilder, various WidgetKits, GF/ST, etc. As such, Cincom can (almost?) do anything it wants with those products (keeping mind the OEM DLL issues affecting two of the WidgetKits).
|-
| Profile/V
| [[Kent Beck]]
| Open Source, under the CPL 1.0 license (Though donations are appreciated). A performance profiler. Not actually part of the VSE distribution.
|}

==People==
A partial list of people that worked at Digitalk/ParcPlace on VSE:

{| class="wikitable"
|-
! Person
! Comments
|-
| Dan Rubel
| Former CTO of Instantiations
|-
| [[George Bosworth]]
| Co-founder of Digitalk and co-creator of Smalltalk/V. Inventor of [[Ephemeron]]s. Worked later on the garbage collector in the Microsoft .Net.
|-
| Jim Anderson
| Co-founder of Digitalk and co-creator of Smalltalk/V.
|-
| [[Mike Teng]]
| Co-founder of Digitalk and co-creator of Smalltalk/V.
|-
| [[Barbara Noparstak]]
| Co-founder of Digitalk.
|-
| [[Lee Breisacher]]
| Early employee of Digitalk and significant contributor to Smalltalk/V Win and PM and VSE.
|-
| [[Allen Wirfs-Brock]]
| Chief scientist at Digitalk-ParcPlace. Currently works for [[Mozilla]].
|-
| [[Eric Clayberg]]
| Creator of [[WindowBuilder]] toolkit. Formerly Vice President of Development at Digitalk-ParcPlace. [http://www.smalltalksystems.com/clayberg/resume.htm]. Formerly Vice President of Product Development at Instantiations [http://www.smalltalksystems.com/clayberg/]. Current board member of Instantiations.
|-
| Stephan B. Wessels
| Digitalk Professional Services, frameworks development. [http://www.preeminent.org/steve/], [http://www.preeminent.org/steve/pages/resume/Smalltalk-experience.html].
|-
| Suzanne Fortman
| Digitalk Marketing. Came back to [[Cincom]] as Smalltalk Program Director.
|-
| Gary Gregory
| Worked on VSE, PARTS, the VM and database interfaces. Now works at [[Seagull Software]] [http://www.seagullsoftware.com].
|-
| Dan Rubel
| Worked on Subpanes/V. Is CTO of Instantiations [http://www.instantiations.com/company/staff.html]
|-
| Roxie Rochat
| Worked on Subpanes/V. Now works for Stoaks Software.[http://stoaks-software.com/Staff/Roxie/Resume.pdf]
|-
| Bart Weller
| Worked on Subpanes/V.
|-
| Ken Cooper
| Worked on Subpanes/V. Got hired by Microsoft in 1997. [http://www.microsoft.com/presspass/press/1997/jun97/coopet.mspx]
|-
| Ted Peters
| Worked on Subpanes/V. Also got hired by Microsoft in 1997. [http://www.microsoft.com/presspass/press/1997/jun97/coopet.mspx]
|-
| Mike Taylor
| Was Vice President of Professional Services at Digitalk. Formerly CEO and president of Instantiations.[http://www.instantiations.com/company/staff.html] Current board member of Instantiations.
|-
|Tim Rowledge
| Worked on a lot of Smalltalk stuff at ParcPlace Systems Inc. Now works on [[Squeak]].
|}

==External links==
*The VSE Mailing List: [http://www.listserv.dfn.de/archives/vswe-l.html VSWE-L]
*[http://www.seagullsoftware.com/ Seagull Software Systems, Inc.]
*Cincom Page about VSE:[http://www.cincomsmalltalk.com/userblogs/cincom/blogView?content=vse http://www.cincomsmalltalk.com/userblogs/cincom/blogView?content=vse]
*Threads of discussion about copyright and licensing:
**[http://groups.google.co.uk/group/comp.lang.smalltalk/browse_thread/thread/187e48c4b968acf6/2979f8877244937f comp.lang.smalltalk Apr. 2005]
*[http://f.webring.com/t/Smalltalk Smalltalk web ring] Smalltalk products and services.
*[https://vs-kb.apis.de/] Welcome to the Visual Smalltalk Knowledge Base!
*[http://www.smalltalking.net/Goodies/VisualSmalltalk/index.htm] Goodies at [http://www.smalltalking.net] Smalltalking web site.
*[http://www.totallyobjects.com/vsfree.htm] Goodies at [http://www.totallyobjects.com/ Totally Objects].
*[http://360businesstool.com/smalltalk] Goodies at [http://360businesstool.com/ 360 Business Tool].

== References ==
<references/>

[[Category:Smalltalk programming language family]]

Smalltalk

2020-03-04T00:12:01Z

Mike1turner: /* List of implementations */

{{About|the programming language||Small talk (disambiguation)}}
{{Infobox programming language
| name = Smalltalk
| logo = Smalltalk80book.jpg
| caption = ''Smalltalk-80: The Language and its Implementation'', a.k.a. the "Blue book", an original book on the language
| paradigm = [[Object-oriented programming|Object-oriented]]
| year = {{Start date and age|1972}} (development began in 1969)
| designer = [[Alan Kay]], [[Dan Ingalls]], [[Adele Goldberg (computer scientist)|Adele Goldberg]]
| developer = Alan Kay, Dan Ingalls, Adele Goldberg, Ted Kaehler, [[Diana Merry]], Scott Wallace, [[L. Peter Deutsch|Peter Deutsch]] and [[PARC (company)|Xerox PARC]]
| latest release version = Smalltalk-80 version 2
| latest release date = {{Start date and age|1980}}
| typing = [[strong typing|Strong]], [[dynamic typing|dynamic]]
| implementations = [[Amber Smalltalk|Amber]], [[Dolphin Smalltalk]], [[Gemstone (database)|GemStone/S]], [[GNU Smalltalk]], [[Pharo]], Smalltalk/X, [[Squeak]], [[IBM VisualAge|VA Smalltalk]], [[VisualWorks]]
| dialects =
| influenced by = [[Lisp (programming language)|Lisp]],<ref name="kay2003">{{cite web|url=http://www.purl.org/stefan_ram/pub/doc_kay_oop_en|title=E-Mail of 2003-07-23|last1=Kay|first1=Alan|last2=Ram|first2=Stefan|date=2003-07-23|work=Dr. Alan Kay on the Meaning of 'Object-Oriented Programming'|access-date=2009-01-03}}</ref> [[Simula]],<ref name="kay2003"/> [[Euler (programming language)|Euler]],<ref name="kay2003"/> [[IMP (programming language)|IMP]],<ref name="kay2003"/> [[Planner (programming language)|Planner]],<ref name="kay2003"/> [[Logo (programming language)|Logo]],<ref name="History"/> [[Sketchpad]],<ref name="kay2003"/> [[ARPAnet]],<ref name="kay2003"/> [[Burroughs B5000]],<ref name="kay2003"/> [[cell (biology)]]<ref name="kay2003"/>
| influenced = [[AppleScript]], [[Common Lisp Object System]], [[Dart (programming language)|Dart]], [[Dylan (programming language)|Dylan]], [[Erlang (programming language)|Erlang]], [[Etoys (programming language)|Etoys]], [[Go (programming language)|Go]], [[Groovy (programming language)|Groovy]], [[Io (programming language)|Io]], [[Ioke (programming language)|Ioke]], [[Java (programming language)|Java]], [[Lasso (programming language)|Lasso]], [[Logtalk]], [[Newspeak (programming language)|Newspeak]], [[NewtonScript]], [[Object REXX]], [[Objective-C]], [[PHP]] 5, [[Python (programming language)|Python]], [[Raku (programming language)|Raku]], [[Ruby (programming language)|Ruby]], [[Scala (programming language)|Scala]], [[Scratch (programming language)|Scratch]], [[Self (programming language)|Self]]
| operating system = [[Cross-platform]] (multi-platform)
| wikibooks = Smalltalk
| website = hide
}}

'''Smalltalk''' is an [[object-oriented programming|object-oriented]], [[dynamically typed]] [[reflection (computer science)|reflective]] [[programming language]]. Smalltalk was created as the language underpinning the "new world" of computing exemplified by "human–computer symbiosis".<ref name="History">{{cite web|first=Alan|last=Kay|url=http://gagne.homedns.org/~tgagne/contrib/EarlyHistoryST.html|title=The Early History of Smalltalk|access-date=2007-09-13}}</ref> It was designed and created in part for [[education]]al use, specifically for [[constructionist learning]], at the Learning Research Group (LRG) of [[PARC (company)|Xerox PARC]] by [[Alan Kay]], [[Dan Ingalls]], [[Adele Goldberg (computer scientist)|Adele Goldberg]], [[Ted Kaehler]], [[Diana Merry]], Scott Wallace, and others during the 1970s.

The language was first generally released as Smalltalk-80. Smalltalk-like languages are in active development and have gathered loyal communities of users around them. ANSI Smalltalk was ratified in 1998 and represents the standard version of Smalltalk.<ref>{{cite web|url=http://www.smalltalk.org/versions/ANSIStandardSmalltalk.html |archive-url=https://web.archive.org/web/20060216073334/http://www.smalltalk.org/versions/ANSIStandardSmalltalk.html |url-status=dead |archive-date=2006-02-16 |title=Smalltalk.org™ | versions | ANSIStandardSmalltalk.html |publisher=Smalltalk.org |access-date=2013-06-25}}</ref>

Smalltalk took second place for "most loved programming language" in the [[Stack Overflow]] Developer Survey in 2017,<ref>[https://insights.stackoverflow.com/survey/2017#technology-most-loved-dreaded-and-wanted-languages Stack Overflow Developer Survey 2017]</ref> but it was not among the 26 most loved programming languages of the 2018 survey.<ref>[https://insights.stackoverflow.com/survey/2018#technology-most-loved-dreaded-and-wanted-languages Stack Overflow Developer Survey 2018]</ref>

== History ==
There are a large number of Smalltalk variants.<ref>{{cite web|url=http://www.smalltalk.org/versions|archive-url=https://web.archive.org/web/20150908041133/http://www.smalltalk.org/versions|url-status=dead|archive-date=2015-09-08|title=Versions|publisher=Smalltalk.org|access-date=2007-09-13}}</ref> 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. The first environment to run the Smalltalk were [[Xerox Alto]] computers.

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 (computer scientist)|Adele Goldberg]] wrote most of the documentation, and [[Dan Ingalls]] implemented most of the early versions. 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".<ref name="History"/> A later variant used for research work is now termed Smalltalk-72 and influenced the development of the [[Actor model]]. Its [[Actor model#Smalltalk|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 [[Simula]]-like class [[Inheritance (computer science)|inheritance]] model of execution), Smalltalk-76 was created. This system had a [[Development environment (software development process)|development environment]] featuring most of the now familiar tools, including a class library code browser/editor. Smalltalk-80 added [[metaclass]]es, 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-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. 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. ANSI Smalltalk has been the standard language reference since 1998.<ref>{{cite web|url=http://www.smalltalk.org/versions/ANSIStandardSmalltalk.html|archive-url=https://web.archive.org/web/20150907224300/http://www.smalltalk.org/versions/ANSIStandardSmalltalk.html|url-status=dead|archive-date=2015-09-07|title=ANSI Smalltalk Standard|publisher=Smalltalk.org|access-date=2007-09-13}}</ref>

Two of the currently popular Smalltalk implementation variants are descendants of those original Smalltalk-80 images. [[Squeak]] is an [[open-source software|open source]] implementation derived from Smalltalk-80 Version 1 by way of Apple Smalltalk. [[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). As an interesting link between generations, in 2001 Vassili Bykov implemented Hobbes, a virtual machine running Smalltalk-80 inside VisualWorks.<ref>[https://web.archive.org/web/20030419030217/http://wiki.cs.uiuc.edu/VisualWorks/Smalltalk-80+in+a+box Hobbes]</ref> ([[Dan Ingalls]] later ported Hobbes to Squeak.)

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. 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. 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|relational database]] servers. 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. IBM initially supported the Digitalk product, but then entered the market with a Smalltalk product in 1995 called VisualAge/Smalltalk. Easel introduced Enfin at this time on Windows and OS/2. 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 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. The merged firm never managed to find an effective response to [[Java (programming language)|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 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]].<ref>{{cite web|url=http://www.seagullsoftware.com/about/history.html#1999|archive-url=https://web.archive.org/web/20020806160121/http://seagullsoftware.com/about/history.html#1999|url-status=dead|archive-date=2002-08-06|title=History|publisher=Seagull Software|access-date=2007-09-13}}</ref> 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]], GemTalk, and Instantiations, continue to sell Smalltalk environments. IBM has 'end of life'd VisualAge Smalltalk having in the late 1990s decided to back Java instead and it is, {{as of|2005|lc=on}}, supported by Instantiations, Inc.<ref>[http://www.instantiations.com/company/ibm-transition.html VisualAge Smalltalk Transition FAQ]</ref> who renamed the product VA Smalltalk (VAST Platform) and continue to release new versions yearly. 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 Smalltalk-80 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 (software)|Seaside]] and [[AIDA/Web]], 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 object-oriented programming languages based on [[Simula]].<ref>The Simula language was also object-oriented and preceded (and was acknowledged as an influence on) Smalltalk but it was a simulation language, not a general purpose programming language.</ref> Smalltalk is also one of the most influential programming languages. Virtually all of the object-oriented languages that came after—[[Flavors (programming language)|Flavors]],<ref>{{cite web|last=Cannon|first=Howard|title=Flavors A non-hierarchical approach to object-oriented programming|url=http://www.softwarepreservation.org/projects/LISP/MIT/nnnfla1-20040122.pdf|work=softwarepreservation.org|access-date=17 December 2013}}</ref> [[CLOS]], [[Objective-C]], [[Java (programming language)|Java]], [[Python (programming language)|Python]], [[Ruby (programming language)|Ruby]],<ref>{{cite web|title=About Ruby|url=https://www.ruby-lang.org/en/about/|work=ruby-lang.org|access-date=17 December 2013}}</ref> and many others—were influenced by Smalltalk. Smalltalk was also one of the most popular languages with the [[Agile Methods]], [[Rapid application development|Rapid Prototyping]], and [[Software design pattern|Software Patterns]]<ref>{{cite web|title=Where Did Refactoring Come From?|url=http://sourcemaking.com/refactoring/where-did-refactoring-come-from|work=sourcemaking.com|access-date=17 December 2013}}</ref> communities. The highly productive environment provided by Smalltalk platforms made them ideal for rapid, iterative development.

Smalltalk emerged from a larger program of [[Advanced Research Projects Agency|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.<ref>{{cite web|title=DARPA / ARPA|url=http://www.livinginternet.com/i/ii_darpa.htm|work=livinginternet.com|access-date=16 December 2013|quote=To meet this need, ARPA established the IPTO in 1962 with a mandate to build a survivable computer network to interconnect the DoD's main computers at the Pentagon, Cheyenne Mountain, and SAC HQ.}}</ref><ref>{{cite web|title=Engelbart's Role in Early Computer Networking|url=http://www.dougengelbart.org/firsts/internet.html|work=dougengelbart.org|access-date=17 December 2013}}</ref> 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.<ref>{{cite web|last=Kay|first=Allen|title=The Early History of Smalltalk|url=http://gagne.homedns.org/~tgagne/contrib/EarlyHistoryST.html|work=gagne.homedns.org|access-date=16 December 2013}}</ref>

Smalltalk environments were often the first to develop what are now common object-oriented software design patterns. One of the most popular is the [[model–view–controller]] (MVC) pattern for [[user interface]] design. The MVC pattern enables developers to have multiple consistent views of the same underlying data. 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. Also, for simulations or games where the underlying model may be viewed from various angles and levels of abstraction.<ref>{{cite journal|last1=Krasner|first1=Glen|last2=Pope|first2=Stephen|title=A Cookbook for Using the Model-View-Controller User Interface Paradigm in Smalltalk -80|journal=Journal of Object-Oriented Programming|date=August–September 1988}}</ref>

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 built-in debugging and object inspection tools that came with Smalltalk environments set the standard for all the [[integrated development environment]]s, starting with [[Lisp Machine]] environments, that came after.<ref>{{cite web|title=Our Influence|url=http://www.cincomsmalltalk.com/main/about-us/the-big-influence-of-smalltalk/|work=cincomsmalltalk.com|access-date=16 December 2013}}</ref>

== Object-oriented programming ==
{{main|Object-oriented programming}}

As in other object-oriented languages, the central concept in Smalltalk-80 (but not in Smalltalk-72) 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 GUI's 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).
# [[Message passing|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 '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)."<ref>{{cite web |last=Kay |first=Alan |title=Prototypes vs Classes (e-mail on Squeak list) |url=http://lists.squeakfoundation.org/pipermail/squeak-dev/1998-October/017019.html |date=October 10, 1998}}</ref>

Unlike most other languages, Smalltalk objects can be modified while the system is running. Live coding and applying fixes ‘on-the-fly’ is a dominant programming methodology for Smalltalk and is one of the main reasons for its incredible efficiency.

Smalltalk is a "pure" object-oriented programming language, meaning that, unlike [[C++]] and [[Java (programming language)|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 [[Subclass (computer science)|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. 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, [[Class (computer science)|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 blocks|Code block]]s—Smalltalk's way of expressing [[anonymous function]]s—are also objects.<ref>{{cite book|last1=Goldberg|first1=Adele|author-link1=Adele Goldberg (computer scientist)|last2=Robson|first2=David|title=Smalltalk-80 The Language|year=1989|publisher=Addison Wesley|isbn=0-201-13688-0|pages=31, 75–89}}</ref>

== Reflection ==
[[Reflection (computer programming)|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 type]]s of input and output parameters. Reflection is a feature of dynamic, interactive languages such as Smalltalk and Lisp. 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.

Reflection is also a feature of having a meta-model as Smalltalk does. 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-80 is a totally reflective system, implemented in Smalltalk-80. Smalltalk-80 provides both structural and computational reflection. Smalltalk is a structurally reflective system which structure is defined by Smalltalk-80 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 <code>CompiledMethod</code>. These get added to classes by storing them in a class's method dictionary. The part of the class hierarchy that defines classes can add new classes to the system. The system is extended by running Smalltalk-80 code that creates or defines classes and methods. In this way a Smalltalk-80 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 fields/slots/instance variables do you define?". So objects can easily be inspected, copied, (de)[[serialization|serialized]] and so on with generic code that applies to any object in the system.<ref>{{cite journal|last=Clark|first=A.N.|title=Metaclasses and Reflection in Smalltalk|year=1997|url=http://citeseerx.ist.psu.edu/viewdoc/summary?doi=10.1.1.33.5755}}</ref>

Smalltalk-80 also provides computational reflection, the ability to observe the computational state of the system. 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), <code>thisContext</code>. By sending messages to <code>thisContext</code> a method activation can ask questions like "who sent this message to me". These facilities make it possible to implement [[coroutine|co-routines]] or [[Prolog]]-like back-tracking 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 (software)|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. Programming the web server using Seaside can then be done using a more conventional programming style.<ref>{{cite web|last1=Ducasse|first1=Stéphane|last2=Lienhard|first2=Adrian|last3=Renggli|first3=Lukas|title=Seaside – A Multiple Control Flow Web Application Framework|url=http://scg.unibe.ch/archive/papers/Duca04eSeaside.pdf|work=scg.unibe.ch|publisher=Software Composition Group Institut fur Informatik und angewandte Mathematik Universitaat Bern, Switzerland|access-date=16 December 2013}}</ref>

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 <code>doesNotUnderstand:</code> message with a [[reification (computer science)|reification]] of the message as an argument. The message (another object, an instance of <code>Message</code>) contains the selector of the message and an <code>Array</code> of its arguments. In an interactive Smalltalk system the default implementation of <code>doesNotUnderstand:</code> 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 Smalltalk-80's reflective facilities.<ref>{{cite journal|last1=Foote|first1=Brian|last2=Johnson|first2=Ralph|title=Reflective Facilities in Smalltalk-80|journal=OOPSLA '89|date=1–6 October 1989|url=http://www.laputan.org/ref89/ref89.html|access-date=16 December 2013}}</ref><ref>{{cite journal|last=Smith|first=Brian C|title=Procedural Reflection in Programming Languages|journal=MIT Technical Report|date=1982-01-01|issue=MIT-LCS-TR-272|url=http://publications.csail.mit.edu/lcs/specpub.php?id=840|access-date=16 December 2013}}</ref>

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.<ref>{{cite journal|last1=Denker|first1=Marcus|last2=Peck|first2=Mariano Martinez|last3=Bouraqadi|first3=Noury|last4=Fabresse|first4=Luc|last5=Ducasse|first5=Stéphane|title=Efficient Proxies in Smalltalk|url=https://hal.inria.fr/inria-00614720/file/Mart11a-IWST11-Marea.pdf}}</ref> 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, [[Futures and promises|promises]], etc. The design of distributed Smalltalk influenced such systems as [[CORBA]].

==Syntax==
{{refimprove section|date=June 2014}}
'''Smalltalk-80''' syntax is rather minimalist, based on only a handful of declarations and reserved words. In fact, only six "keywords" are reserved in Smalltalk: <code>true</code>, <code>false</code>, <code>nil</code>, <code>self</code>, <code>super</code>, and <code>thisContext</code>. These are properly termed ''pseudo-variables'', identifiers that follow the rules for variable identifiers but denote bindings that a programmer cannot change. The <code>true</code>, <code>false</code>, and <code>nil</code> pseudo-variables are [[singleton pattern|singleton]] instances. <code>self</code> and <code>super</code> refer to the receiver of a message within a method activated in response to that message, but sends to <code>super</code> are looked up in the superclass of the method's defining class rather than the class of the receiver, which allows methods in subclasses to invoke methods of the same name in superclasses. <code>thisContext</code> refers to the current activation record. The only built-in 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 built-in 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 (computer scientist)|Ralph Johnson]], demonstrating all the basic standard syntactic elements of methods:<ref>[http://sdmeta.gforge.inria.fr/Programmez/OnTheWeb/Art2-Eng-AminimalistSyntax.pdf]
[http://scg.unibe.ch/archive/lectures/DucasseLectures/Duca00y1SmalltalkLectures.pdf]</ref>
<source lang="smalltalk">
exampleWithNumber: x
| y |
true & false not & (nil isNil) ifFalse: [self halt].
y := self size + super size.
#($a #a "a" 1 1.0)
do: [ :each |
Transcript show: (each class name);
show: ' '].
^x < y
</source>

===Literals===

The following examples illustrate the most common objects which can be written as literal values in Smalltalk-80 methods.

Numbers. The following list illustrates some of the possibilities.

<source lang="smalltalk">
42
-42
123.45
1.2345e2
2r10010010
16rA000
</source>

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:

<source lang="smalltalk">$A</source>

Strings are sequences of characters enclosed in single quotes:

<source lang="smalltalk">'Hello, world!'</source>

To include a quote in a string, escape it using a second quote:

<source lang="smalltalk">'I said, ''Hello, world!'' to them.'</source>

Double quotes do not need escaping, since single quotes delimit a string:

<source lang="smalltalk">'I said, "Hello, world!" to them.'</source>

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 unique—there 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:

<source lang="smalltalk">#'foo'</source>

If the sequence does not include whitespace or punctuation characters,
this can also be written as:

<source lang="smalltalk">#foo</source>

Arrays:

<source lang="smalltalk">#(1 2 3 4)</source>

defines an array of four integers.

Many implementations support the following literal syntax for ByteArrays:

<source lang="smalltalk">#[1 2 3 4]</source>

defines a ByteArray of four integers.

And last but not least, blocks ([[anonymous function]] literals)

<source lang="smalltalk">[... Some smalltalk code...]</source>

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:

<source lang="smalltalk">| index |</source>

declares a temporary variable named index which contains initially the value <code>nil</code>.

Multiple variables may be declared within one set of bars:

<source lang="smalltalk">| index vowels |</source>

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 '<code>:=</code>' syntax. So:

<source lang="smalltalk">vowels := 'aeiou'</source>

Assigns the string <code>'aeiou'</code> 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 left-facing arrow ⟨←⟩ (like in the 1963 version of the [[ASCII]] code). Smalltalk originally accepted this left-arrow 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 colon-equals syntax.

===Messages===

The message is the most fundamental language construct in Smalltalk. Even control structures are implemented as [[message passing|message sends]]. Smalltalk adopts by default a synchronous, single [[dynamic dispatch|dynamic message dispatch]] strategy (as contrasted to the asynchronous, [[multiple dispatch]] strategy adopted by some other object-oriented languages).

The following example sends the message 'factorial' to number 42:

<source lang="smalltalk">42 factorial</source>

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:

<source lang="smalltalk">aRatherBigNumber := 42 factorial</source>

"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:

<source lang="smalltalk">2 raisedTo: 4</source>

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:

<source lang="smalltalk">'hello world' indexOf: $o startingAt: 6</source>

which answers the index of character 'o' in the receiver string, starting the search from index 6. The selector of this message is "indexOf:startingAt:", 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 Java-like syntax might be written as:

<source lang="java">new Rectangle(100, 200);</source>

It's unclear which argument is which. By contrast, in Smalltalk, this code would be written as:

<source lang="smalltalk">Rectangle width: 100 height: 200</source>

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 (non-alphabetic) characters can be used as what are called ''binary messages''. These allow mathematical and logical operators to be written in their traditional form:

<source lang="smalltalk">3 + 4</source>

which sends the message "+" to the receiver 3 with 4 passed as the argument (the answer of which will be 7). Similarly,

<source lang="smalltalk">3 > 4</source>

is the message ">" sent to 3 with argument 4 (the answer of which will be false).

Notice, that the Smalltalk-80 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:

<source lang="smalltalk">3 factorial + 4 factorial between: 10 and: 100</source>

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 "between:and:" 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,

<source lang="smalltalk">(3 factorial + 4) factorial between: 10 and: 100</source>

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 "between:and:", answering false.

Note that because the meaning of binary messages is not hardwired into Smalltalk-80 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:

<source lang="smalltalk">3 + 4 * 5</source>

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:

<source lang="smalltalk">3 + (4 * 5)</source>

Unary messages can be ''[[method chaining|chained]]'' by writing them one after another:

<source lang="smalltalk">3 factorial factorial log</source>

which sends "factorial" to 3, then "factorial" to the result (6), then "log" to the result (720), producing the result 2.85733.

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.

<source lang="smalltalk">
| window |
window := Window new.
window label: 'Hello'.
window open
</source>

If a series of messages are sent to the same receiver as in the example above, they can also be written as a ''[[method cascading|cascade]]'' with individual messages separated by semicolons:

<source lang="smalltalk">
Window new
label: 'Hello';
open
</source>

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:

<source lang="smalltalk">[ :params | <message-expressions> ]</source>

Where '':params'' is the list of parameters the code can take. This means that the Smalltalk code:

<source lang="smalltalk">[:x | x + 1]</source>

can be understood as:

:<math>f</math> : <math>f(x) = x + 1</math>

or expressed in lambda terms as:

:<math>\lambda x</math> : <math>x + 1</math>

and

<source lang="smalltalk">[:x | x + 1] value: 3</source>

can be evaluated as

:<math>f(3) = 3 + 1</math>

Or in lambda terms as:

:<math>(\lambda x : x + 1) 3 _\beta\rightarrow 4</math>

The resulting block object can form a [[closure (computer science)|closure]]: it can access the variables of its enclosing lexical scopes at any time. Blocks are [[first-class object]]s.

Blocks can be executed by sending them the ''value'' message (compound variations exist in order to provide parameters to the block e.g. 'value:value:' 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 if-then-else in Smalltalk is written and implemented as

{{pre|expr ifTrue: [statements to evaluate if expr] ifFalse: [statements to evaluate if not expr] 
''True methods for evaluation'' 
'''ifTrue:''' trueAlternativeBlock '''ifFalse:''' falseAlternativeBlock 
    ^trueAlternativeBlock value

''False methods for evaluation'' 
'''ifTrue:''' trueAlternativeBlock '''ifFalse:''' falseAlternativeBlock 
    ^falseAlternativeBlock value}}

<source lang="smalltalk">positiveAmounts := allAmounts select: [:anAmount | anAmount isPositive]</source>

Note that this is related to [[functional programming]], wherein patterns of computation (here selection) are [[abstraction (computer science)|abstracted]] into [[higher-order function]]s. For example, the message ''select:'' on a Collection is equivalent to the higher-order function [[Filter (higher-order function)|filter]] on an appropriate [[function object|functor]].<ref>{{cite book|last1=Goldberg|first1=Adele|author-link1=Adele Goldberg (computer scientist)|last2=Robson|first2=David|title=Smalltalk-80 The Language|year=1989|publisher=Addison Wesley|isbn=0-201-13688-0|pages=17–37}}</ref>

==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:
<source lang="smalltalk">
result := a > b
ifTrue:[ 'greater' ]
ifFalse:[ 'less or equal' ]
</source>
Blocks are also used to implement user-defined control structures, enumerators, visitors, exception handling, pluggable behavior and many other patterns.
For example:
<source lang="smalltalk">
| aString vowels |
aString := 'This is a string'.
vowels := aString select: [:aCharacter | aCharacter isVowel].
</source>
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 "[:aCharacter | aCharacter isVowel]"), 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:
<source lang="smalltalk">
| 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: [:aRect | aRect containsPoint: aPoint].
</source>
The exception handling mechanism uses blocks as handlers (similar to CLOS-style exception handling):
<source lang="smalltalk">
[
some operation
] on:Error do:[:ex |
handler-code
ex return
]
</source>
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").

==Classes==
This is a stock class definition:<ref>{{cite book|last1=Goldberg|first1=Adele|author-link1=Adele Goldberg (computer scientist)|last2=Robson|first2=David|title=Smalltalk-80 The Language|year=1989|publisher=Addison Wesley|isbn=0-201-13688-0|pages=39–53}}</ref>
<source lang="smalltalk">
Object subclass: #MessagePublisher
instanceVariableNames: ''
classVariableNames: ''
poolDictionaries: ''
category: 'Smalltalk Examples'
</source>
Often, most of this definition will be filled in by the environment. Notice that this is a message to the <code>Object</code> class to create a subclass called <code>MessagePublisher</code>. In other words: classes are [[first-class object]]s 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.
<source lang="smalltalk">
publish
Transcript show: 'Hello World!'
</source>
The following method demonstrates receiving multiple arguments and returning a value:
<source lang="smalltalk">
quadMultiply: i1 and: i2
"This method multiplies the given numbers by each other and the result by 4."
| mul |
mul := i1 * i2.
^mul * 4
</source>
The method's name is <code>#quadMultiply:and:</code>. The return value is specified with the <code>^</code> operator.

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.

===Instantiating classes===
The following code:
<source lang="smalltalk">
MessagePublisher new
</source>
creates (and returns) a new instance of the MessagePublisher class. This is typically assigned to a variable:
<source lang="smalltalk">
publisher := MessagePublisher new
</source>
However, it is also possible to send a message to a temporary, anonymous object:
<source lang="smalltalk">
MessagePublisher new publish
</source>

==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.
<source lang="smalltalk">
Transcript show: 'Hello, world!'.
</source>
Note that a Transcript window would need to be open in order to see the results of this example.

==Image-based persistence==
Most popular programming systems separate static program code (in the form of class definitions, functions or procedures) from dynamic, or [[Run time (program lifecycle phase)|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 don't 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 non-Class objects) in an [[system image|image]] file. The image can then be loaded by the Smalltalk [[virtual machine]] to restore a Smalltalk-like system to a prior state.<ref>{{cite web|title=Image-Based Persistence|url=http://book.seaside.st/book/advanced/persistency/image-based-persistency|work=book.seaside.st|access-date=17 December 2013}}</ref> This was inspired by FLEX, a language created by [[Alan Kay]] and described in his M.Sc. thesis.<ref>{{cite journal|last=Kay|first=Allen|title=FLEX – A flexible extendable language|journal=University of Utah MsC Thesis|year=1968|url=http://www.mprove.de/diplom/gui/kay68.html}}</ref>

Smalltalk images are similar to (restartable) [[core dump]]s 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 (programming language)|Lisp]], often use image-based persistence as well. 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. 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 multi-user systems. The most obvious is the ability to do transactions with multiple users accessing the same database in parallel.<ref>{{cite web|last=Fowler|first=Martin|title=Memory Image|url=http://martinfowler.com/bliki/MemoryImage.html|work=martinfowler.com|access-date=17 December 2013}}</ref>

==Level of access==
Everything in Smalltalk-80 is available for modification from within a running program. This means that, for example, the [[integrated development environment|IDE]] can be changed in a running system without restarting it. In some implementations, the syntax of the language or the [[garbage collection (computer science)|garbage collection]] implementation can also be changed on the fly. Even the statement <code>true become: false</code> is valid in Smalltalk, although executing it is not recommended.

==Just-in-time compilation==
{{main|Just-in-time compilation}}
Smalltalk programs are usually compiled to [[bytecode]], which is then interpreted by a [[virtual machine]] or dynamically translated into machine-native code.

==List of implementations==
*[[Amber Smalltalk]], runs on [[JavaScript]] via transpilation
*[[Cincom]] has the following Smalltalk products: [[ObjectStudio]], [[VisualWorks]] and WebVelocity.
*[[Visual Smalltalk Enterprise]], and family, including Smalltalk/V
*[[F-Script (programming language)|F-Script]]
*GemTalk Systems, [[Gemstone (database)|GemStone/S]]
*[[GNU Smalltalk]]
*[[StepTalk]], GNUstep scripting framework uses Smalltalk language on an [[Objective-C]] runtime
*[[IBM VisualAge|VisualAge]] Smalltalk
*VAST Platform (VA Smalltalk), developed by Instantiations, Inc
*[[Little Smalltalk]]
*Object Arts, [[Dolphin Smalltalk]]
*Object Connect, [[Smalltalk MT]] Smalltalk for Windows
*[[Pharo]] Smalltalk, an open-source [[cross-platform]] language
*[[PharoJS]] an open-source [[transpiler]] from Smalltalk to Javascript, extending the [[Pharo]] environment
*[[Pocket Smalltalk]], runs on Palm Pilot
*[[Squeak]], open source Smalltalk
*[[Etoys (programming language)|eToys]], a visual programming system for learning
*[[Strongtalk]], for Windows, offers optional strong typing

==See also==
* [[Objective-C]]
* [[GLASS (software bundle)]]
* [[Distributed Data Management Architecture]]

==References==
{{Reflist|30em}}

==Further reading==
*{{cite book|last=Goldberg|first=Adele|author-link=Adele Goldberg (computer scientist)|title=Smalltalk-80: The Interactive Programming Environment|date=December 1983|publisher=Addison-Wesley|isbn=0-201-11372-4}}
*{{cite book|editor1-last=Goldberg|editor1-first=Adele|editor1-link=Adele Goldberg (computer scientist)|editor2-last=Kay|editor2-first=Alan|editor2-link=Alan Kay|title=Smalltalk-72 Instruction Manual|url=http://www.bitsavers.org/pdf/xerox/parc/techReports/Smalltalk-72_Instruction_Manual_Mar76.pdf|access-date=2011-11-11|date=March 1976|publisher=[[Xerox]] [[Palo Alto Research Center]]|location=Palo Alto, California}}
*{{cite book|last1=Goldberg|first1=Adele|author-link1=Adele Goldberg (computer scientist)|last2=Robson|first2=David|title=Smalltalk-80: The Language and its Implementation|url=https://archive.org/details/smalltalk80langu00gold|date=May 1983|publisher=Addison-Wesley|isbn=0-201-11371-6|url-access=registration}}
*{{cite book|title=Smalltalk 80: The Language|last1=Goldberg|first1=Adele|author-link1=Adele Goldberg (computer scientist)|last2=Robson|first2=David|date=11 January 1989|publisher=Addison-Wesley|isbn=0-201-13688-0}}
*{{cite journal|last=Kay|first=Alan C.|author-link=Alan Kay|date=March 1993|title=The Early History of Smalltalk|journal=ACM [[SIGPLAN]] Notices|publisher=[[Association for Computing Machinery|ACM]]|volume=28|issue=3|pages=69–95|url=http://www.metaobject.com/papers/Smallhistory.pdf|doi=10.1145/155360.155364}}
*{{cite book|editor-last=Krasner|editor-first=Glen|title=Smalltalk-80: Bits of History, Words of Advice|url=https://archive.org/details/crkevnprvokatol00prazgoog|date=August 1983|publisher=Addison-Wesley|isbn=0-201-11669-3}}
*{{cite book|last1=Nierstrasz|first1=Oscar|last2=Ducasse|first2=Stéphane|last3=Pollet|first3=Damien|last4=Black|first4=Andrew P.|title=Squeak by Example|date=2009-10-07|publisher=Square Bracket Associates|location=Kehrsatz, Switzerland|isbn=3-9523341-0-3|url=http://www.squeakbyexample.org}}
*{{cite book|last1=Nierstrasz|first1=Oscar|last2=Ducasse|first2=Stéphane|last3=Pollet|first3=Damien|last4=Black|first4=Andrew P.|title=Pharo by Example|url=http://pharobyexample.org/|archive-url=https://web.archive.org/web/20091021035635/http://pharobyexample.org/|url-status=dead|archive-date=October 21, 2009|date=February 23, 2010|publisher=Square Bracket Publishing|location=Kehrsatz, Switzerland|isbn=978-3-9523341-4-0}}
*{{cite book|last=Winston|first=Patrick Henry|title=On to Smalltalk|date=September 3, 1997|publisher=Addison Wesley|location=MIT, USA|isbn=978-0201498271|url-access=registration|url=https://archive.org/details/effectsoftempera00baeh}}
*{{cite book|last=Brauer|first=Johannes|title=Programming Smalltalk – Object-Orientation from the Beginning|date=2015|publisher=Springer|isbn=978-3-658-06823-3}}
*{{cite journal|date=August 1981|title=Special Issue on Smalltalk|journal=[[Byte (magazine)|Byte]]|publisher=McGraw-Hill|volume=6|issue=8|url=https://archive.org/details/byte-magazine-1981-08|access-date=2013-10-18}}
**{{cite journal|date=August 1981|title=Introducing the Smalltalk-80 System|first=Adele|last=Goldberg|author-link=Adele Goldberg (computer scientist)|journal=[[Byte (magazine)|Byte]]|publisher=McGraw-Hill|volume=6|issue=8|url=https://archive.org/stream/byte-magazine-1981-08/1981_08_BYTE_06-08_Smalltalk#page/n15/mode/2up|access-date=2013-10-18}}
**{{cite journal|last=Ingalls|first=Dan|author-link=Dan Ingalls|date=August 1981|title=Design Principles Behind Smalltalk|journal=[[Byte (magazine)|Byte]]|publisher=McGraw-Hill|volume=6|issue=8|url=https://archive.org/stream/byte-magazine-1981-08/1981_08_BYTE_06-08_Smalltalk#page/n299/mode/2up|access-date=2011-11-11}}
**{{cite journal|last=Tesler|first=Larry|author-link=Larry Tesler|date=August 1981|title=The Smalltalk Environment|journal=[[Byte (magazine)|Byte]]|publisher=McGraw-Hill|volume=6|issue=8|url=https://archive.org/stream/byte-magazine-1981-08/1981_08_BYTE_06-08_Smalltalk#page/n103/mode/2up|access-date=2016-05-02}}

==External links==
{{Wikibooks|Programming:Smalltalk}}
*[http://stephane.ducasse.free.fr/FreeBooks.html Free Online Smalltalk Books]
*[https://github.com/Cuis-Smalltalk/Cuis-Smalltalk-Dev Cuis Smalltalk]
*[http://pharo-project.org Pharo Smalltalk]
*[http://squeak.org Squeak Smalltalk]
*[http://www.cincomsmalltalk.com Cincom Smalltalk VisualWorks]
*[http://www.object-arts.com Dolphin Smalltalk]
*[http://smalltalk.gnu.org GNU Smalltalk]
*[http://www.exept.de/ Smalltalk/X]
*[http://www.strongtalk.org/ StrongTalk]
*[http://amber-lang.net Amber Smalltalk]
*[http://www.redline.st/ Redline Smalltalk]
*[https://github.com/astares/ScarletSmallTalk Scarlet Smalltalk]
*[http://www.cincomsmalltalk.com Cincom Smalltalk (ObjectStudio, VisualWorks)]
*[http://www.instantiations.com/products/vasmalltalk/ VA Smalltalk]
*[http://www.gemstone.com/smalltalk GemStone]
*[http://seaside.gemstone.com GLASS (GemStone, Linux, Apache, Seaside, and Smalltalk)]
*[http://www.objectconnect.com/ Smalltalk MT]
*[https://lively-web.org/users/bert/Smalltalk-78.html Smalltalk-78 online emulator]
*[http://opensmalltalk.org/ OpenSmalltalk cross-platform virtual machine for Squeak, Pharo, Cuis, and Newspeak]

{{Smalltalk programming language}}
{{Programming languages}}

{{Authority control}}

[[Category:Programming languages]]
[[Category:Class-based programming languages]]
[[Category:Dynamically typed programming languages]]
[[Category:Free educational software]]
[[Category:Object-oriented programming languages]]
[[Category:Programming languages created by women]]
[[Category:Programming languages created in 1972]]
[[Category:1972 software]]
[[Category:Smalltalk programming language family]]
[[Category:Cross-platform free software]]
[[Category:Free compilers and interpreters]]

Seaside (software)

2020-03-04T00:08:43Z

Mike1turner: /* External links */

{{Infobox software
| name = Seaside
| logo = Seaside.png
| logo caption = Seaside logo
| screenshot = Seaside-development.png
| caption = Screenshot of a web application in development mode
| developer = The Seaside Team<ref>[http://www.seaside.st/community/contributors/ The Seaside Team]</ref>
| released = {{Start date and age|2002}}
| latest release version = 3.4.0
| latest release date = {{Start date and age|2019|08|24}}<ref>https://github.com/SeasideSt/Seaside/releases</ref>
| status = Active
| programming language = [[Smalltalk]]
| operating system = [[Cross-platform]]
| platform = [[IA-32]], [[x86-64]], [[ARM architecture|ARM]]
| size =
| language = English
| genre = [[Web framework]]
| license = [[MIT License|MIT]]
| website = {{URL|seaside.st}}
| repo = {{URL|github.com/SeasideSt/Seaside|Seaside Repository}}
}}
'''Seaside''', an acronym that stands for “Squeak Enterprise Aubergines Server with Integrated Development Environment,” is computer [[software]], a [[web framework]] to develop [[web application]]s in the programming language [[Smalltalk]]. It is distributed as [[free and open-source software]] under an [[MIT License]].

Seaside provides a component architecture in which [[web page]]s are built as [[Tree (data structure)|trees]] of individual, [[State (computer science)|stateful]] components, each encapsulating a small part of a page. Seaside uses [[continuation]]s to model multiple independent flows between different components.<ref>[http://www.iam.unibe.ch/~scg/Archive/Papers/Duca04eSeaside.pdf Seaside – a Multiple Control Flow Web Application Framework]</ref> Thus, it is a continuation-based web framework<ref>[http://www-128.ibm.com/developerworks/java/library/j-cb03216/ IBM DeveloperWorks: Crossing borders: Continuations, Web development, Java programming]</ref> based on the ability to manipulate the execution stack of some implementations of Smalltalk.

==Key features==
Seaside's implementation of [[continuation]]s was an initial point of interest in its first several years of existence following its 2002 release. Continuations provide a mechanism for rollback and resumption, a useful provision for the [[web browser]] environment in which ''refresh'' and ''back'' buttons may interrupt the flow of processing. This resolves many common issues with running web applications, like adequately sustaining the state on the server-side even when the web browser’s ‘back’ and ‘forward’ buttons are used. Continuation servers give the developer the ability to maintain state on the server in a scalable manner.<ref>[http://scg.unibe.ch/archive/papers/Duca07a-SeasideIEEE-SCG.pdf Seaside: A Flexible Environment for Building Dynamic Web Applications]</ref> The subsequent improvement of web browser implementations of [[JavaScript]] since 2002 has made the continuations aspect of Seaside less significant, by allowing client browsers to keep track of state better.

A distinctive feature of Seaside is its integrated development environment, providing access to development tools and debugging support within an application. In development-mode, unhandled errors are reported to the web page; developers can access and alter the program code and state directly from the web page, allowing bug identifying and fixing processes to occur within an [[integrated development environment]] (IDE).<ref>[http://www.seaside.st/documentation/debugging Debugging Seaside Applications]</ref>

A Seaside application is a set of interacting components. Each one stores state across page views and can ''render'' itself to the [[HTML]] stream. Thus, it is straightforward to write a component once and then reuse it elsewhere in an application. Seaside also supports the notion of tasks, which allow a programmer to describe the high-level logic of component interaction.

Seaside is not template-oriented, and does not offer generating or using HTML templates; HTML [[Markup language|markup]] is generated programmatically. (The Seaside-based Pier content-management framework does offer wiki-markup syntax for templating.) Seaside uses [[Callback (computer programming)|callbacks]] on [[Closure (computer programming)|closures]] to specify actions to be taken when clicking on a link or submitting a form. The developers and users of Seaside argue that this helps enforce separation of structure (markup) from content and presentation ([[Cascading Style Sheets]] (CSS)).<ref>[http://www.cincomsmalltalk.com/userblogs/avi/blogView?showComments=true&entry=3257728961 Avi Bryant explains why Seaside doesn't use templates]</ref> Seaside's combination of components, callbacks, and closures can significantly reduce the semantic gap between a complex workflow and its representation in code.<ref>[http://www.slideshare.net/GideonSireling/web-application-frameworks-a-comparative-study Web Application Frameworks: A Comparative Study]</ref>

Seaside supports [[Ajax (programming)|Ajax]] through integration with [[script.aculo.us]] and [[jQuery]]. Seaside also supports [[Comet (programming)|Comet]]-style server-push technology.<ref>[http://www.lukas-renggli.ch/smalltalk/seaside/videos/comet.mov Screencast: Seaside Comet Chat Application]</ref>
Seaside can work with either Smalltalk-based web server implementations or other non-Smalltalk ones (Nginx, Apache).

==Philosophy==
Over the last few years, some best practices have come to be widely accepted in the web development field:
* Share as little state as possible.
* Use clean, carefully chosen, and meaningful [[URL]]<nowiki/>s.
* Use templates to separate the model from the presentation.

Seaside deliberately breaks all of these rules. Avi Bryant describes it as a 'heretical' framework. He argues that this careful and reasoned rejection of the conventional wisdoms of web development has led to a very effective model for developing web applications.<ref>{{cite web|url=http://conferences.oreillynet.com/cs/os2006/view/e_sess/8942 |title='Web Heresies: The Seaside Framework' Session notes, OSCON 2006 |url-status=bot: unknown |archiveurl=https://web.archive.org/web/20140830152243/http://conferences.oreillynet.com/cs/os2006/view/e_sess/8942 |archivedate=2014-08-30 }}</ref>

==Ports==
The main development of Seaside is implemented in [[Pharo]] Smalltalk.<ref>[http://seaside.st/about/history "Seaside 2.9 is current implemented on Pharo that serves as a reference implementation."]</ref> Ports for other Smalltalk dialects exist.
The original develoment of Seaside was done on [[Squeak]] in the early 2000's.
Michel Bany implemented ports to [[VisualWorks]] through Seaside version 2.7; [[Cincom Systems]] supports Seaside as part of [[VisualWorks]] as of early 2008. Instantiations announced Seaside support in its VAST (VA Smalltalk) Platform version 8.0 in 2009. The VAST Platform has continued to support Seaside through its latest version.
Esteban Maringolo maintained the 2.8 port, plus some other add-ons (such as [[script.aculo.us]]) for [[Dolphin Smalltalk]] X6.<ref>[http://dolphinseaside.blogspot.com/ Seaside for Dolphin Smalltalk blog]</ref>
Gemstone Systems implemented a port to [[Gemstone (database)|Gemstone/S]].<ref>[http://lists.squeakfoundation.org/pipermail/seaside/2006-November/009886.html Seaside2.6g]</ref>
A port of 2.8 was completed for GemStone,<ref>[http://gemstonesoup.wordpress.com/2007/07/12/seaside-28-ported-to-gemstones/ Seaside 2.8]</ref> and a preliminary version of 3.0 runs on [[GNU Smalltalk]] 3.0a and later.<ref>[http://smalltalk.gnu.org/faq/43 Does Seaside run on GNU Smalltalk], GNU Smalltalk FAQ</ref>

==Criticisms==
* Compared to other [[web framework]]s, Seaside is memory intensive. One [[Session management|session]] could accumulate several hundred kilobytes of RAM. A later release, version 2.8, significantly reduces this size (e.g., a formerly typical 200 KB size becomes 50 KB).
* Seaside does not follow [[representational state transfer]] (REST) by default. Instead, [[Uniform Resource Locator]]s (URLs) hold session key information, and meaningful URLs must be generated explicitly.

==Open-source projects using it==
Many open-source projects use Seaside, some of which are:
* Magritte – a meta-description framework with a tight integration into Seaside
* Pier – a [[content management system]] and high level application framework for Seaside
* ADK Project

==Proprietary projects using it==
Many proprietary projects use Seaside, some of which are:
* [[Dabble DB]] – web-based database application<ref>[http://weblog.infoworld.com/udell/2006/10/31.html Jon Udell article in InfoWorld] {{webarchive|url=https://web.archive.org/web/20070212055642/http://weblog.infoworld.com/udell/2006/10/31.html |date=2007-02-12 }}</ref>
* Cmsbox – a [[content management system]] (CMS) made available by netstyle.ch for the Swiss market.

==See also==
{{Portal|Free and open-source software}}
* [[Solution stack]], GLASS
* [[Nagare (web framework)]]
* [[List of content management systems]]
* [[Comparison of web frameworks]]

==References==
{{Reflist|2}}

==External links==
* {{Official website|seaside.st}}
* {{Official website|book.seaside.st/book}}
* {{github|https://github.com/seasidest/seaside}}

{{Smalltalk programming language}}
{{Web frameworks}}

[[Category:Smalltalk programming language family]]
[[Category:Web frameworks]]
[[Category:Software using the MIT license]]