Smalltalk
Från Rilpedia
 |
Den här artikeln anses undermålig och kan behöva skrivas om helt för att leva upp till Wikipedias artikelstandard. Diskutera frågan på diskussionssidan och förbättra gärna artikeln. Var uppmärksam på artikelns innehåll. Motivering: bristande stringens och osakligheter |
Smalltalk är ett objektorienterat programspråk som togs fram vid Xerox Palo Alto Research Center (PARC) under 1970- och 1980-talet, av Alan Kay, Dan Ingalls, Ted Kaehler, Adele Goldberg, m.fl. Första versionen släpptes redan 1972. De första publika versionerna spriddes under början av 1980-talet, baserade på framförallt Smalltalk-80.
Även om Smalltalk i sig inte blivit någon större framgång anses det ha varit grunden till många andra framsteg för datoranvändning, som till exempel användningen av fönsterhantering, ikoner för val på bildskärm, den moderna objektorienterade vokabulären, metoder som Model-View-Controller (MVC), plattformsoberoende via användandet av Virtuell Maskin (VM), Just In Time-kompilering (JIT) redan 1983 (då ibland kallad Deutsch-Schiffman-kompilering), samt tongivande i tillkomsten och utvecklandet av designmönster (eng. Design Patterns).
Trots att Smalltalk fortfarande för en lite tillbakadragen roll bland de "stora lagren av programmerare" frodas och görs fortfarande innovativ (föregångs-) utveckling inom bland annat webbteknologi, IDE-utveckling samt extremprogrammering med bland annat ledande utveckling inom testdriven utveckling och verktyg och tekniker för refactoring.
Innehåll |
Kort historik
Arbetet med Smalltalk började på Xerox PARC i början av 1970-talet. (3000 rader BASIC 1972)
- Skapade begreppet objektorienterat.
- Mycket av dagens terminologi inom objektorientering kommer från Smalltalk
- Även Javas rekommenderade regler för namngivning tagna från Smalltalk.
- Avsikten var att bygga ett kraftfullt informationssystem som skulle kunna växa och förändras i takt med användarens idéer och önskemål.
- I Smalltalk-gruppen eller intilliggande grupper på XeroxParc var man också först med
- Fönstersystem med bitmappade displayer, pop-up-menyer, mm.
- Influerade Apples Macintosh.
- Ethernet.
- Postscript.
- De flesta Smalltalksystem består av en plattformsberoende virtuell maskin (VM) och en plattformsoberoende exekveringsomgivning (image). Kompilering sker till en tänkt maskins kod. Vid exekveringen tolkas eller översätts denna kod av VM:en för att till slut exekveras på den aktuella plattformen. Det vanliga är Just In Time compiling (JIT) utnyttjas. Vissa Smalltalksystem har haft JIT sedan 1983 (då ibland kallad Deutsch-Schiffman-kompilering) [1].
- Smalltalk, eller folk som jobbar med Smalltalk, har också varit dominerande i:
- Designmönster
- Extreme Programming (XP), extrem programmering
- Teorier och mönster för gränssnittskonstruktion. Exempelvis konstruerades den kända paradigmen/designmönstret Model-View-Controller (MVC) i samband med utvecklandet av Smalltalk i slutet av 70-talet.
Se till exempel http://www.nada.kth.se/kurser/kth/2D1359/01-02/contents/forelasningar/f16.pdf för lite mer detaljerad historik.
Eller varför inte ta en titt på demon av hur Smalltalk såg ut i slutet av 70- och början av 80-talen: video
Inledande programexempel
Program som skriver 'Hello World!'
Transcript show: 'Hello World!'.
Något om utvecklingsmiljöer/IDEer för Smalltalk
Smalltalk har alltid mer eller mindre varit synonymt med utvecklingsmiljö, programmeringsverktyg, tillgång till systemkällkoden eller kort sagt en väldigt avancerad IDE (Integrated Development Environment). Redan från början, då handlar det om 1970-talet, gick utvecklingen av Smalltalk hand i hand med utvecklingen av avancerade programmeringsverktyg och IDEer. Ända sedan dess har Smalltalk-IDEer varit föregångare i denna utveckling. Även om det under 80-talet kom IDE:er för andra programspråk och senare, under slutet av 1990- och början av 2000-talet, har det väl mer eller mindre blivit kutym bland utvecklare att använda IDEer, anser många att Smalltalks IDEer fortfarande är överlägsna. Delvis kan Smalltalk-IDEernas utveckling kanske bero på att man hela tiden utvecklat de dominerande Smalltalksystemen som tvådelad enhet där den ena delen är språket och den andra delen utvecklingsmiljön. Om man ska spekulera kan denna kraftfullhet kanske till stora delar bero på Smalltalkspråkets väldigt dynamiska natur, att språket i stort sett är definierat i sig själv, samt det öppna systemet med all kod för systemverktygen tillgänglig, vilket det gör det väldigt enkelt att modifiera och konstruera programutvecklingssystem i dessa miljöer.
VisualWorks utvecklingsmiljö
- Referenser
VisualWorks
www.cincomsmalltalk.com
Squeak
Fler programexempel
Några korta exempel konstruerade med VisualWorks\Smalltalk www.cincomsmalltalk.com.
Konstruera och använda klass
Klient-Server
Server som öppnas på port 4711, väntar på en klient och skriver ett meddeland som säger vad tiden är (på servern, med serverns locale-inställningar) för att därefter terminera.
server := SocketAccessor newTCPserverAtPort: 4711. "En TCP-server" server listenFor: 1. "hantera en anslutande klient i taget" client := server accept. "vänta på klient" stream := client readAppendStream. "skapa en läs- och skrivström" stream lineEndTransparent. "hantera radslut på ett för olika plattformstyper transparent sätt" stream nextPutAll: 'The time is: '; print: Timestamp now; cr. stream close. client close. server close.
Vi startar servern (via att exempelvis skriva texten i ett Workspace och exekvera den med Do it). Sen testar vi att det hela fungerar direkt från ett terminalfönster:
>telnet localhost 4711 The time is: den 3 september 2006 13:30:22.317
Alternativt kan vi skriva en Smalltalk-klient som ansluter till servern och skriver ut svaret i det aktuella fönstret:
client := SocketAccessor newTCPclientToHost: 'localhost' port: 4711. stream := client readAppendStream. stream lineEndTransparent. reply := stream upTo: Character cr. stream close. client close.
Svaret ligger i variabeln reply.
Delad (synkad) kö med trådning och delayhantering
Ett mycket enkelt exempel på att Smalltalk har kraftfulla klasser för att hantera trådar och synkroniserade processer. I följande exempel skapas en instans av klassen SharedQueue. En (lättvikts-)process/tråd skriver till den en annan läser från den och skriver ut resultatet i Transcript-fönstret. En SharedQueue synkroniserar in- och utmatning, dvs processer kan skriva till den kö som den hanterar och andra processer kan läsa från denna kö men försöker man läsa från kön utan att det finns något på den vilas läsprocessen tills det att någon skrivit på kön. Bland annat för att illustrera en del olika möjligheter och mekanismer använder vi en instans av Delay för att vila en tråd, resume för att starta en icke startad tråd och terminate för att stoppa en tråd. För den som vill använda mer avancerade trådmekanismer mm, finns mängder av exempel i de olika Smalltalksystemen och deras dokumentation.
queue := SharedQueue new.
delay := Delay forMilliseconds: 700. "Vi använder en delay för att 'simulera'
att allt inte skrivs på en gång"
stop := false.
"skapa consumerprocess"
consumer := [[stop] whileFalse: [Transcript print: queue next; space]] newProcess.
"Skapa och starta process som skriver på kön (fork både skapar och startar)"
[1 to: 10 do: [:i | "Vi gör en liten (for-loop) från 1 till 10 med det positiva steget 1"
queue nextPut: i.
delay wait]. "Låt tråden vila en stund"
stop := true.
consumer terminate "vi stoppar consumern"] fork.
consumer resume "Starta consumerprocessen"
Läsa innehållet från en URL
Om vi vill läsa innehållet från Wikipedias svenska huvudsida kan vi helt enkelt exekvera följande (i ett Workspace, från en klass/program eller så):
url := 'http://sv.wikipedia.org/' asURI. url readStream contents
Resultatet blir, i detta fall, den HTML som den angivna sidan är uppbyggd av.
Skriva till och läsa från fil
Skapa en ny fil och skriv något på den:
file := 'test.txt' asFilename. writeStream := file writeStream. writeStream nextPutAll: 'Vi testar att skriva på fil'. writeStream cr. writeStream nextPutAll: 'Datum och tid är: '. writeStream print: Timestamp now. writeStream close
Sen kan vi läsa innehållet från filen:
file := 'test.txt' asFilename. file contentsOfEntireFile
Svaret blir: 'Vi testar att skriva på fil Datum och tid är: den 3 september 2006 16:49:58.182'
För mer avancerade sätt att hantera filer, som med readStream eller readAppendSream, se systemet
En servlet
En enkel servlet som svarar med vad datumet och tiden är på servern:
- Klassdefinition
Smalltalk defineClass: #TimeServlet
superclass: #{VisualWave.HttpServlet}
indexedType: #none
private: false
instanceVariableNames: ''
classInstanceVariableNames: ''
imports: ''
Kategori: 'Wikipedia'
- GET-metod
doGet: aRequest response: aResponse aResponse write: '<html><body>' , Timestamp now printString, '</body></html>'
- Starta server
Vi startar en server på port 8008. Se systemdokumentationen, speciellt http://www.cincomsmalltalk.com/pdf/WebAppDevGuide.pdf
- Testa
Skriv följande i en WebBrowser:
http://localhost:8008/servlet/TimeServlet
- Om vi också vill klara av POST (i fallet nedan anropar vi metoden doGet:response: då den ju fungerar även i POST-fallet)
doPost: aRequest response: aResponse self doGet: aRequest response: aResponse
