hoe het leren van Smalltalk je een betere ontwikkelaar kan maken

Smalltalk wordt algemeen gezien als een oude, stervende taal—een antiek uit vervlogen tijden. Niets is minder waar.

Smalltalk is nog steeds zeer relevant. Het is een uitstekende onderwijstaal voor het onderwijzen van programmeren aan mensen die geen technische achtergrond hebben. Het is een superlatieve prototyping taal voor startups. Het is een industriële-kracht enterprise taal gebruikt door bedrijven zowel grote als kleine over de hele wereld. Er zijn goede redenen om te overwegen het gebruik van moderne Smalltalk vandaag, omdat er veel is veranderd in de afgelopen jaren om de vooruitzichten te verbeteren.

u hoeft Smalltalk niet te gebruiken in de productie van vandaag, maar probeer iets te coderen in Smalltalk en kijk hoe het voelt. Het moet vertrouwd aanvoelen, omdat Smalltalk ‘ s implementatie van het object-oriented (OO) paradigma zo uitstekend is dat het een hele generatie OO talen heeft beïnvloed, zoals Objective-C, Python, Ruby, CLOS, PHP 5, Perl 6, Erlang, Groovy, Scala, Dart, Swift, enzovoort.

door Smalltalk te leren, zult u begrijpen hoe al die handige functies in de OO-talen van vandaag zijn ontstaan. Het leren van Smalltalk kan je ook een grote voorsprong geven in het programmeren van vaardigheden onder je leeftijdsgenoten, en het kan een geweldig hulpmiddel zijn voor het onderwijzen van programmeren aan beginners.

wat heeft Smalltalk ons gegeven?Smalltalk heeft een rijke erfenis aan bijdragen aan de software-industrie. Kijk maar naar deze lijst van functies en technologieën die het introduceerde:

• Smalltalk introduceerde de wereld in de taal virtuele machine (of VM), die software platformonafhankelijk maakt. Dit is dezelfde technologie die Java (JVM) en.net ondersteunt, evenals Android (Dalvik).
• Smalltalk was ook een pionier op het gebied van JIT (just-in-time) compilatie, een techniek om de prestaties van bytecode software zoals Java drastisch te verbeteren.
• van Smalltalk kwam de eerste moderne IDE (integrated development environment), die een teksteditor, een systeem-of klassebrowser, een object-of property inspector en een debugger omvatte. Dit leidde tot de vele IDEs die ontwikkelaars de voorkeur vandaag, zoals Visual Studio, Xcode, en IntelliJ IDEA. Persoonlijk denk ik dat geen van deze IDEs kan vergelijken met Smalltalk ‘ s IDE in eenvoud, elegantie, en snelheid van ontwikkeling; het origineel is nog steeds de beste!
• vanaf het allereerste begin had Smalltalk sluitingen, die lexicaal eersteklas functies zijn. In essentie is een afsluiting een callback functie die nietlokale variabelen kan zien op de locatie waar ze zijn gedefinieerd. Dit kan u helpen om veel compactere en leesbare code te schrijven. Sluitingen vinden hun weg naar veel belangrijke talen, zoals Java, C#, en PHP.
• Smalltalk was de eerste taaltool om “live” programmering en geavanceerde debugging technieken zoals on-the-fly inspectie en code veranderingen tijdens het uitvoeren te ondersteunen. Vandaag, live debugging is mogelijk in C# met Visual Studio ‘ s “bewerken en doorgaan” en in Java met HotSwap.
• Smalltalk introduceerde MVC (Model-View-Controller) in de wereld. MVC is een software architecturaal patroon voor het implementeren van gebruikersinterfaces. Het is populair bij desktop GUI-toepassingen en webapplicaties. Tegenwoordig is het de architectuur die de meeste webontwikkelaars als eerste leren.Smalltalk is voor een groot deel verantwoordelijk voor het geven van test-driven development (of TDD) en extreme programming (of XP), die beide zeer invloedrijk zijn in de huidige standaard agile praktijken.
• Smalltalk maakte “duck typing” een huishoudelijk woord (nou ja, als je huis een programmeur heeft). Duck Typen is waar “type controle” wordt uitgesteld tot runtime—wanneer reflectie mogelijkheden worden gebruikt om correct gedrag te garanderen. We vinden eend typen in vele talen vandaag, met inbegrip van Java, Python, Common Lisp, Go, Groovy, Objective-C, en PHP.
• Smalltalk was een pionier in de ontwikkeling van objectdatabases. Hoewel ze niet in de mainstream, object databases hebben hun nichemarkten. Het beste voorbeeld van een object database product is GemStone/S, die goed geschikt is voor schaalbare, high-performance, multitier gedistribueerde systemen.
• Smalltalk gaf ons de eerste refactoring browser. Natuurlijk, refactoring ondersteuning kan worden gevonden in de meeste IDEs vandaag.
• Smalltalk was behulpzaam bij het ontwikkelen van de grafische gebruikersinterface (of GUI) en de “what you see is what you get” (WYSIWYG) gebruikersinterface.

maar hoe kan het leren van Smalltalk mij een betere ontwikkelaar maken?

Smalltalk heeft verschillende killer features die hun tijd ver vooruit waren:

• image-based persistence
• objecten: alles is een object, en objecten communiceren alleen via berichten (de “zuiverste” OO, en een van de vroegste)
• “Live” programmering
• geavanceerde debugging technieken zoals on-the-fly code wijzigingen
• een eenvoudige, overzichtelijke IDE interface
• Domain-specific languages (DSLs): De enige manier waarop Smalltalk werkt, dus programmeurs moeten zich richten op het probleemdomein met behulp van een taal en notatie die natuurlijk is voor dat domein

en er zijn een paar andere functies die Smalltalk ook speciaal maken.

het belangrijkste voordeel van Smalltalk als een productief taal-en leermiddel is dat het de meeste, zo niet alle, cognitieve stress in mainstream OO-talen zoals Java wegneemt. Smalltalk presenteert geen syntactische rommel of afleidende functies. Het gaat gewoon uit de weg, zodat u al uw aandacht kunt richten op het probleem of de toepassing bij de hand. Het is niet dat Java is een slechte taal voor het zijn complexer (en het hebben van 30-karakter klassenamen); wat ik zeg is dat het leren van een onbelemmerde OO taal kan eigenlijk maken je een betere Java programmeur als je eenmaal begrijpt de OO Concepten vanuit een ander perspectief.Het elimineren van cognitieve stress is een fundamenteel doel van vele talen—bijvoorbeeld Python, Ruby, Elixir, Elm en Go. Zelfs als je het niet voelt, de stress is er. Er wordt vaak gezegd dat programmeren in Smalltalk of Python lijkt op Zen; je geest stroomt gewoon moeiteloos met de taak. Dit is de schoonheid en waarde van taal eenvoud, en Smalltalk heeft dit in schoppen.

in Smalltalk wordt OO gedestilleerd naar de meest basisbegrippen van klassen en methoden, metaclasses en reflectie, en vooral het doorgeven van berichten. Smalltalk, op grond van zijn Object zuiverheid en consistentie, zal u een diep beter begrip van object-georiënteerde programmering en hoe het te gebruiken om zijn beste effect te geven.De eenvoud van Smalltalk maakt het ook een ideale leertaal voor het leren van programmeren, vooral als je geen technische achtergrond hebt. De eenvoud van de taal en de tools stelt u in staat om uw energie te concentreren op het leren van programmeertechnieken, niet op taalformaliteiten.

Hoe werkt Smalltalk? De image-based approach to programming

Smalltalk ‘ s belangrijkste claim op fame is zijn image-based approach to software creation. Een afbeelding is een momentopname van het geheugen dat alle objecten in uw lopende toepassing of systeem bevat. Het vat de volledige uitvoeringsstatus van uw programma samen. Een afbeelding kan worden opgeslagen op de schijf, en de uitvoering kan later worden hervat precies vanaf waar je gebleven was!

Smalltalk ‘ s Afbeelding klinkt misschien een beetje gek, maar in feite vertoont het een sterke gelijkenis met iets dat veel gebruikt wordt in het vandaag: systeem images in OS virtualisatie zoals we vinden in VMware en VirtualBox. Je moet niet vergeten dat Smalltalk oorspronkelijk een stand-alone besturingssysteem was toen het werd gemaakt op Xerox PARC in de jaren 1970.

de afbeelding van Smalltalk lijkt ook sterk op de DOM van een webpagina (Document Object Model). Merk op dat een webapplicatie is in wezen een systeem op zichzelf, afgezonderd in de webbrowser en geweigerd directe toegang tot het bestandssysteem van de host en andere bronnen. Wanneer een webbrowser sluit, kan de status van de dynamische website worden opgeslagen of gecached, en de volgende keer dat de browser hervat, kan de website worden hersteld in de browser (met enkele beperkingen).

zelfs de lage spreadsheet past nauw bij het beeldconcept. Het omvat de hele staat van executie. Het heeft geen toegang tot de systeembronnen van de host. Het kan worden opgeslagen en hersteld. En je moet weten dat spreadsheets nog steeds worden gebruikt om geavanceerde modellen en applicaties met een eigen taal te ontwikkelen.

het beeldconcept is dus vrij algemeen. Het is zo ‘ n leuke manier om software te ontwikkelen dat er een versie van het image concept is gemaakt voor JavaScript in de levendige Kernel.

alles in Smalltalk is een object

geen uitzonderingen: alles is een object. Er zijn geen primitieve gegevenstypen. Er zijn geen controlestructuren zoals selectie en iteratie! Alles in Smalltalk wordt gedaan door het verzenden van berichten naar objecten. Dit is wat Smalltalk zo eenvoudig, elegant en gemakkelijk te leren maakt. Dit is wat de taal syntactisch zo zuiver maakt.

bijvoorbeeld, het volgende codefragment breidt de Nummerklasse uit om een niet-recursieve factoriële bewerking te ondersteunen:

Number extend
ifFalse: .
^ (c fold: ) ]]].

7 factorial printNl.

7 my_factorial printNl. "should be the same result as the previous line"

hier is ifTrue: een trefwoordbericht dat wordt verzonden naar het Booleaanse object dat het resultaat is van het evalueren van de expressie (zelf < 2). Het argument voor het trefwoord bericht is een code blok (afgebakend door vierkante haakjes). Eigenlijk is ifTrue: het eerste deel van een tweedelig trefwoordbericht, het tweede deel is ifFalse:.

het ongeldige bericht nieuw wordt verzonden naar de klasse OrderedCollection om een nieuwe collectie aan te maken. Het printNl bericht wordt verzonden naar het resultaat (dat een object is) van het verzenden van het mijn_factorial bericht naar het nummer 7. Het hele ding leest bijna als natuurlijke taal!

computationele reflectie in Smalltalk

reflectie in Smalltalk is bijzonder waardevol als een middel voor een programma om zijn eigen structuur en berekening tijdens runtime te inspecteren. Dit geeft enorme macht, waardoor programma ‘ s zich kunnen uitbreiden met nieuwe klassen en methoden of vragen “Wie heeft mij dit bericht gestuurd?”

computationele reflectie wordt gebruikt om een krachtige manier te implementeren om fouten te verwerken. Wanneer een object een bericht ontvangt dat het niet implementeert, ontvangt het een doesNotUnderstand: – bericht, samen met een vervaging van het oorspronkelijke bericht. Er zijn veel dingen die het programma kan doen met de doesNotUnderstand: bericht, met inbegrip van zichzelf uit te breiden met nieuwe functionaliteit!

het beeldconcept en de reflectie maken het ook mogelijk dat Smalltalk de toepassing / IDE-grens elimineert. Alles wat je nodig hebt om te ontwikkelen, debuggen, en uitvoeren van uw toepassing is in de afbeelding. Het is niet nodig om ooit uw applicatieomgeving te verlaten. Het is een volledig holistische benadering van softwareontwikkeling die alles meer Zen-achtig en productief maakt.

Smalltalk ‘ s renaissance

de laatste 15 jaar van ontwikkeling in de wereld van Smalltalk hebben de taal veel aantrekkelijker gemaakt.

Smalltalk is nu beschikbaar voor front-end webprogrammering met Amber Smalltalk, dat naar JavaScript wordt getransporteerd. Amber ontwikkeling vindt volledig plaats in de browser. Een van de verbazingwekkende dingen over Amber is dat wanneer u een JavaScript-bibliotheek importeert, de objecten kunnen worden behandeld net als Smalltalk objecten.

in 2002 werd het Seaside web framework uitgebracht en werd het de meest populaire tool voor webontwikkeling in Smalltalk. De continuation-based aanpak bood een conventionele “call / return” mechanisme voor uw webapplicatie. Het kan helpen bij het oplossen van problemen zoals de dubbele aanvraag en terug knop problemen. Heel revolutionair voor zijn tijd, en nog steeds niet vaak aangenomen in andere web frameworks.

het Pharo-project begon in 2008 om zich te concentreren op moderne software-engineering en ontwikkelingstechnieken. Het heeft Smalltalk veel verder gebracht dan het vorige open-source project genaamd Squeak, dat gebaseerd was op het eerbiedwaardige Smalltalk-80 dialect. Het Pharo project heeft ook geleid tot onderzoek naar een nieuw soort IDE genaamd de glamoureuze Toolkit. Het is gebaseerd op het idee dat uw programmeeromgeving “vormbaar” moet zijn om aan uw behoeften te voldoen.

vorig jaar werd de hoog aangeschreven Dolphin Smalltalk open source, een andere geweldige optie voor fans van Smalltalk. Dolphin Smalltalk is vaak geprezen voor het hebben van een van de beste implementaties van de Smalltalk IDE.

de Smalltalk-erfenis: Programmeren leuk maken

wanneer je gebruik maakt van de vele faciliteiten van moderne software ontwikkeling zoals de JVM, Eclipse IDE, closures, “live coding,” MVC, TDD, VMware, en zelfs de gewone oude web app, denk dan terug aan hun oorsprong in Smalltalk en heb een groter respect voor wat je doet. Hebben een grotere waardering voor de talen die u gebruikt, of ze nu objectief-C, Python, Ruby, Groovy, Scala, Dart, of Swift.

het werken met de taal die al deze geweldige functies en technologieën heeft voortgebracht, biedt een unieke kans om uw kennis, uw mentale scherpte en uw productiviteit als softwareontwikkelaar sterk te verbeteren. Het woord “fun” gaat niet altijd in discussie over software engineering, maar ik denk dat Smalltalk—en zijn OO broeders—zorgen voor de lage cognitieve barrière en het gemak van programmeren dat software engineering leuk kan maken.