Smalltalk (programmeertaal)

Uit Wikipedia, de vrije encyclopedie
(Doorverwezen vanaf Programmeertaal Smalltalk)
Voor het artikel over de verzamelnaam voor informele gesprekken, zie Smalltalk (taal).
Smalltalk
Paradigma Objectgeoriënteerd
Verschenen 1980
Ontworpen door Alan Kay, Dan Ingalls, Adele Goldberg, Larry Tesler
Ontwikkeld door Alan Kay, Dan Ingalls, Adele Goldberg, Xerox Parc
Typesysteem dynamisch
Implementaties Squeak, VisualWorks
Beïnvloed door Lisp, Simula
Invloed op Objective-C, Self, Java, Dylan, AppleScript, NewtonScript, Python, Scala, Perl 6
Besturingssysteem Multiplatform
Portaal  Portaalicoon   Informatica

Smalltalk is een objectgeoriënteerde programmeertaal met dynamische typen, die ontwikkeld werd bij Xerox PARC door Alan Kay, Dan Ingalls, Ted Kaehler, Adele Goldberg, Larry Tesler en anderen in de jaren zeventig. De taal werd oorspronkelijk uitgebracht als Smalltalk-80 en wordt sindsdien in brede kring gebruikt.

Smalltalk wordt voortdurend verder ontwikkeld en rondom de taal is een trouwe gebruikersgemeenschap ontstaan. Smalltalk heeft grote invloed gehad op de ontwikkeling van vele andere programmeertalen, onder andere Objective C, Java en Ruby. De invloed op die laatste is zelfs zo groot dat sommige Smalltalkers Ruby beschouwen als Smalltalk met een andere syntaxis. Veel programmeerconcepten uit de jaren negentig ontstonden in de Smalltalk-gemeenschap, bijvoorbeeld de toepassing van het concept 'design patterns' op software, Extreme Programming en refactoring. Een bekend Smalltalker is Ward Cunningham, de uitvinder van het WikiWiki-concept.

Structuur[bewerken | brontekst bewerken]

Enkele kenmerken van Smalltalk:

  • "Alles is een object." Tekenreeksen (strings), getallen, booleans, klassedefinities, codeblokken en geheugen worden allemaal voorgesteld als objecten. De uitvoering bestaat uit het versturen van boodschappen tussen objecten. Elke boodschap kan naar elk object gestuurd worden; het ontvangende object bepaalt of deze boodschap gepast is en hoe het deze gaat verwerken.
  • Alles kan aangepast worden. Als men de IDE wil aanpassen, dan kan dat - in een draaiend systeem, zonder te hercompileren of opnieuw te beginnen. Als een nieuwe controlestructuur in de taal gewenst is, kan die worden toegevoegd. In sommige implementaties kan zelfs de syntaxis van de taal worden aangepast, of de manier waarop het opruimen van objecten (garbage collection) gebeurt.
  • Typen zijn dynamisch. Dit betekent dat typen niet in de code hoeven te worden gedefinieerd, wat de taal veel compacter maakt. (Zoals gezegd is het het ontvangende object eerder dan de compiler dat uitmaakt of een bepaalde boodschap gepast is.)
  • Opbouwen van gebruikersinterfaces volgens het Model-View-Controller-model.
  • Dynamische vertaling: moderne commerciële virtuele machines compileren bytecodes naar de juiste machinecode, wat platformonafhankelijkheid combineert met snelheid. Dit idee werd zo'n tien jaar later overgenomen door Java en kreeg daar de naam just in time compilatie of JIT-compilatie.

Een van de meest verrassende aspecten van Smalltalk is dat traditionele programmeerstructuren als if-then-else, for, while, enz. geen deel uitmaken van de taal. Dit alles wordt geïmplementeerd via objecten. Beslissingen worden bijvoorbeeld genomen door een iftrue-boodschap te sturen naar een boolean-object en een codefragment door te geven dat moet worden uitgevoerd als de boolean true als resultaat geeft. Er zijn slechts drie ingebouwde uitvoerbare constructies:

  • een boodschap sturen naar een object;
  • een object toekennen aan een variabele;
  • een object teruggeven als resultaat van een methode;

en enkele syntactische constructies voor het declareren van objecten met een vaste waarde ('literal objects').

Het volgende codevoorbeeld voor het zoeken van de klinkers in een string illustreert de Smalltalk-stijl ( | dient voor de declaratie van variabelen, : voor de declaratie van parameters). 

| aString vowels |
aString := 'Dit is een string'.
vowels := aString select: [:aCharacter | aCharacter isVowel].

In de laatste regel wordt naar de string een boodschap "select:" gestuurd, met het daaropvolgende codeblok als argument. Dit is de code in de superklasse Collection die al het werk doet: 

| newCollection |
newCollection := self species new.
self do: [:each | 
    (aBlock value: each) 
        ifTrue: [newCollection add: each]].
^newCollection

Deze code reageert op de boodschap door in een lus alle leden te behandelen (dit doet de methode "do:") en dus de aBlock-code één keer te evalueren voor elk teken; aBlock (aCharacter isVowel geeft bij evaluatie als resultaat een boolean, waarnaar vervolgens een ifTrue: gestuurd wordt. Als de boolean waar (true) is, wordt het teken toegevoegd aan de tekenstring die als resultaat zal gegeven worden.

Omdat select gedefinieerd is in de abstracte klasse Collection, kunnen we het ook zo gebruiken: 

| rectangles aPoint |
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].

Geschiedenis[bewerken | brontekst bewerken]

Smalltalk werd ontwikkeld door een groep onderzoekers onder leiding van Alan Kay in het XEROX Palo Alto Research Center. De eerste implementatie, onder de naam Smalltalk-71, werd in een paar ochtenden gecreëerd na een weddenschap over de mogelijkheid om een programmeertaal die gebaseerd was op het idee van het doorgeven van boodschappen (geïnspireerd door Simula) te implementeren in "één pagina code". Een latere versie, die ook echt gebruikt werd voor onderzoekswerk, is nu bekend als Smalltalk-72. De syntaxis en het uitvoeringsmodel waren heel anders dan bij het moderne Smalltalk, zozeer zelfs dat het als een andere taal kan worden beschouwd.

Na ingrijpende revisies ontstond de versie die bekendstaat als Smalltalk-76. Die versie beschikte over overerving en een syntaxis die veel dichter aanleunt bij die van Smalltalk-80. Er werd ook een ontwikkelomgeving voor gemaakt, inclusief de meeste tools die Smalltalkgebruikers nu kennen.

Smalltalk-80 voegde meta-klassen toe, wat helpt om de uitspraak "alles is een object" vol te houden door eigenschappen en gedrag te associëren met individuele klassen (bijvoorbeeld om verschillende manier om instanties te creëren te ondersteunen).

Smalltalk-80 was de eerste versie die beschikbaar werd gemaakt buiten PARC, eerst als Smalltalk-80 Version 1 aan enkele bedrijven en universiteiten (voor een peer review). In 1983 volgde een algemeen beschikbare implementatie, Smalltalk-80 Version 2, die werd uitgebracht als een "image" (platformonafhankelijk bestand met objectdefinities) en een specificatie voor een virtuele machine (Virtual Machine).

Twee van de momenteel populaire Smalltalk-implementaties zijn afstammelingen van de originele Smalltalk-80-images. Squeak is afgeleid van Smalltalk-80 Version 1 via Apple SmallTalk. VisualWorks is afgeleid van Smalltalk-80 Version 2 via Smalltalk-80 2.5 en ObjectWorks (allebei producten van ParcPlace Systems, een spin-off van XEROX PARC die opgericht werd om Smalltalk te commercialiseren).

Implementaties[bewerken | brontekst bewerken]

Externe links[bewerken | brontekst bewerken]

Overgenomen van "https://nl.wikipedia.org/w/index.php?title=Smalltalk_(programmeertaal)&oldid=56089321"