Scala is een object-functionele programmeer- en scripttaal voor algemene toepassingen. Het is statisch getypeerd, ontworpen om oplossingen bondig uit te drukken, op een type-veilige, elegante en lichtgewichte wijze. Het integreert de voordelen van objectgeoriënteerde en functionele principes. Moderne software-constructies (closures, monaden, staartrecursie etc.) kunnen opgezet worden met bijvoorbeeld genericiteit, hogere-ordefuncties, patroonvergelijking, meervoudige overerving, call-by-name-evaluatie etc. Scala draait op Java's virtual machine (JVM) en kan enkele tekortkomingen van Java wegnemen (bijvoorbeeld meervoudige-overerving van klassen).
Achtergrond De opensourcetaal is ontwikkeld op en wordt onderhouden door het EPFL (École Polytechnique Fédérale de Lausanne) in Zwitserland, Typesafe Inc./Typesafe Switzerland Sàrl en bijdragers onder leiding van hoogleraar Martin Odersky.
In regels code worden Java-programma's meestal met een factor twee of meer gereduceerd. Verder is de plaats van de code in de bronbestanden niet rigide, waardoor er een efficiëntere structuur kan worden gebruikt en deze bestanden in aantal kunnen worden teruggebracht. Het gebruik van veel herhaalde boilerplate-code wordt in Scala veelal voorkomen. Javaprogrammeurs kunnen dit oplossen door editors te gebruiken die automatisch boilerplate code toevoegen, maar dit maakt de broncode minder overzichtelijk.
Scala is een statisch getypeerde taal. Het typesysteem is een van de meest geavanceerde van alle programmeertalen, deels omdat het de uitgebreide ideeën van functioneel programmeren en objectgeoriënteerd programmeren combineert. Het typesysteem probeert alomvattend logisch, volledig en consistent te zijn. Door het wetenschappelijk gebaseerde ontwerp overschrijdt het de beperkingen van het Java-typesysteem. Het typesysteem kan intimiderend zijn, vooral voor de programmeurs die voornamelijk bekend zijn met een dynamisch getypeerde taal. De type-inferentie verbergt echter het grootste deel van de complexiteit en is de vriend van de programmeur.
De werking in een Integrated Development Environment (IDE) kan door de ingebouwde 'Scala Presentation Compiler' als proactief ervaren worden. Deze compiler controleert de broncode automatisch na elke wijziging en heeft een aantal inferentiemechanismen. Deze mechanismen trekken gevolg aan de code, bijvoorbeeld waar het einde van een statement is of over het resulterende type (type-inferentie). Een eenvoudig voorbeeld van type-inferentie; een initialisatie met 42 geeft die variabele het statische type Int (integer), een initialisatie met "Hello World!" is automatisch java.lang.String getypeerd. Dito de variabele die een functie een resultaat teruggeeft; daardoor krijgt de functie het type van die variabele.
Type-inferentie ontlast de programmeur van het nagaan en herhaaldelijk opnieuw specificeren van typen, Scala voelt daarom aan als een dynamisch getypeerde taal, met als groot voordeel: typen worden tijdens compile-time eenmalig in de ontwikkelomgeving en niet meerdere malen tijdens run-time geëvalueerd waardoor de executable snel is.
Bekende Java-ontwikkeltools, zoals Eclipse, IntelliJ IDEA of NetBeans IDE, bieden ook ondersteuning voor Scala. Alhoewel de byte-code interoperabel is met (bestaande) Java code, draagt Scala niet zoals Java de last van vroegere ongelukkige keuzes.Bedoeld wordt: type erasure, checked exceptions en het non-unified typesysteem
Tijd-as Concept Deployment Technologie Design-time Compile-time Runtime Conventioneel statisch type BewerkenSyntax-checking Executie Error checking
Type checking Scala IDE BewerkenSyntax-checking Type checking Executie
Middels tooling wordt edit, compile en run-time ten opzichte van een conventionele fase naar een eerdere fase verschoven. Bijvoorbeeld error-checking tijdens editing, type-checking, nooit na de compileerfase. Dit levert een sneller en betrouwbaarder uitvoerbaar bestand op.
De naam is een samenstelling van 'scalable language' en drukt de zeer compact gehouden universele taalkern uit welke de mogelijkheid biedt om veelgebruikte taalelementen, zoals extra operators of extra control-statements in gebruikersklassen te implementeren, en daarmee de taal uit te breiden. Met andere woorden: de taal is niet hardgecodeerd in de compiler. Er bestaat bijvoorbeeld ook de mogelijkheid een eigen domein-specifieke taal te creëren.
Schaalbaar kan uitgelegd worden in de volgende domeinen: Scala is geschikt voor parallelle uitvoering en is schaalbaar in productieomgevingen met een groeiend aantal processors. Niet alleen het feit dat het mogelijk is om in Scala functioneel te programmeren maakt Scala geschikt voor parallelle programma's; Scala heeft ook een beter alternatief voor multithreading met Java: Actors; Op de taalkern kan een taaluitbreiding gemaakt worden, bijvoorbeeld in bibliotheken (bijv. het break statement). Scala kan zowel imperatief en/of functioneel gebruikt worden; De taal kan zowel als broncode voor compiler maar ook door z'n compactheid als scripttaal voor de interpreter gebruikt worden, bijvoorbeeld tijdens het programmeren of het testen. Er kan Scala gecompileerde code gemaakt worden variërend voor smartphones tot grote multicore-of multiprocessor-platforms; En dat op verschillende platforms: JVM, CLR (CLR de mobiele apps uitgezonderd) en LLVM; Rijke uitbreidingen op JVM en/of CLR-bibliotheken; Met Scala kan een interpreter voor een domein-specifieke taal (DSL) ingebed worden; Een meegeleverd voorbeeld van flexibiliteit in taaluitbreiding is de XML-integratie. Op het gebied van architectuur heeft het de volgende vier taalmechanismen die schaalbare samenstelling van systemen bevorderen: expliciete selftypes, abstracte type members en genericiteit, geneste klassen en mixin-compositie met behulp van traits. James Gosling, medebedenker van de programmeertaal Java, werd gevraagd welke JVM-taal uitgezonderd Java hij zou kiezen; "Scala", antwoordde hij prompt.James Strachan, die Groovy heeft gecreëerd, beschrijft Scala als mogelijke opvolger van Java: "Ik kan eerlijk zeggen dat als iemand me het "Programming in Scala"-boek van Martin Odersky, Lex Spoon & Bill Venners in 2003 had laten zien, ik waarschijnlijk nooit Groovy zou hebben gemaakt."
Voorbeelden Hello World, commandline Een Hello, world!-programma in Scala: object HelloWorld extends App { println("Hello, world!") } In tegenstelling met het Java-voorbeeldprogramma is er geen klassedeclaratie nodig en niets hoeft als static gedeclareerd te worden, in plaats daarvan wordt er een singleton-object gebruikt. Het entrypoint main wordt via de trait App ingebracht.
Hello World als een Scala-shellscript Unix Windows #!/bin/sh exec scala "$0" "$@" !# // Hier het Scala-script println("Hello, world!") // Print de eventuele argumenten args.toList foreach println::#! @echo off call scala %0 %* goto :eof ::!# println("Hello, world!") args.toList foreach println
Hello World in een grafische gebruikersomgeving Een Hello, World!-GUI-programma in Scala: thumb|Scala REPL HelloWorld als GUI import swing._
object HelloWorld extends SimpleSwingApplication { def top = new MainFrame { title = "Hello, world!" contents = new Button { text = "Click Me!"
Hello World, .Net-versie Een Hello, World!-.Net-programma in Scala: thumb|Scala HelloWorld als .Net-dialoog import swing._
object HelloDotNetWorld { def main(args: Array[String]) { System.Windows.Forms.MessageBox.Show("Hello, .net world!")
Illustratie van de verschillen tussen syntaxis van Java en Scala // Java:
int moelijkeFunctieMetDerdeMachtsEnLog(int num) { int numSquare = num*num; return (int) (Math.cbrt(numSquare) + Math.log(numSquare)); } // Scala: Een taaleigen versie // Gebruikt type-inferentie, geen 'return'-statement, // gebruikt 'toInt()'-methode, zonder haakjes
import math._ def moelijkeFunctieMetDerdeMachtsEnLog(num: Int) = { val numSquare = num * num (cbrt(numSquare) + log(numSquare)) toInt } Hier zijn de volgende verschillen tussen de syntaxis zichtbaar: In Scala zijn puntkomma's niet altijd vereist; Hoofdletter voor datatypen: Int, Double, Boolean in plaats van respectievelijk int, double, boolean. Datatype van een variabele, parameter of functie staat achter de identifier, zoals in Pascal, in plaats van vooraan; Procedure of functie worden voorafgegaan met het def sleutelwoord; Een functie of methode heeft een =-teken, anders is het een procedure (geeft object Unit terug); Scala kent voor variabelen het onderscheid tussen wijzigbare variabelen (mutable) en variabelen met een vaste waarde (immutable). Lokale of klassevariabelen moeten voorafgegaan worden met het val- voor een onveranderlijke of var-sleutelwoord voor een muteerbare variabele; De return-operator is niet verplicht, maar wel toegestaan; de waarde van het laatst uitgevoerde statement is de returnwaarde en definieert het type van de functie (type-inferentie); In plaats van de Java-cast-operator (Type) foo, gebruikt Scala foo.asInstanceOf[Type], maar meestal een gespecialiseerde conversiefunctie zoals toDouble of toInt; In plaats van de Java's import math.*; gebruikt Scala import math._. De underscore is Scala's jokerteken; Infix-notatie: Een functie of methode def foo() kan op de eenvoudig wijze worden aangeroepen als foo. Methode thread.send(signo) kan worden aangeroepen als thread send signo; en methode foo.toString() kan gebruikt worden met foo toString. Deze vrijheid staat gebruik als Domain-Specific Language toe. Enkele andere basisverschillen in de syntaxis: Array-elementen worden geadresseerd als functie aanroepen, bijvoorbeeld array(i) in plaats van array[i]; Generieke typen worden aangeduid tussen vierkante haken in plaats van Java's vishaken: List<String>; In plaats van de pseudotype void heeft Scala het actuele singleton-object Unit.
Geschiedenis van Scala Scala is het geesteskind van Martin Odersky, hoogleraar aan de École Polytechnique Fédérale de Lausanne. Zijn doel was om wetenschappelijk onderzoek op het gebied van programmeertalen aan te wenden om Java te verbeteren. Hij had vanwege zijn academische achtergrond een voorliefde voor het functioneel programmeren. Een van zijn bijdragen, na een poging tot ontwikkeling van Pizza (een super-set van Java met enkele features van functional programming), was Java Generics in Java 1.5. (Odersky is in 2011 uitgeroepen tot Top Java Ambassador.) Tijdens het werken aan die uitbreiding, voelde hij de grote beperkingen van Java die zijn ideeën dwarsboomden. Vanaf dat moment heeft hij een stap teruggenomen en is met een schone lei aan iets nieuws begonnen. Dit echter zonder de bestaande infrastructuur – JVM en de Java-library's – overboord te zetten. Door een te radicale aanpak mondde dit uit in een puur theoretische en daardoor onpraktische taal, Funnel genaamd. Uiteindelijk werd pragmatisch met Scala opnieuw begonnen aan een taal die het midden moest houden tussen academisch en praktisch.
Odersky zag het belang van functioneel programmeren voor de Javagemeenschap al vroeg in (bijvoorbeeld beter voorspelbare werking, concurrency, bewijsbaarheid van programmacorrectheid), maar wist in die tijd geen belangstelling te krijgen. Langzamerhand begint dit inzicht zich wijder te verspreiden onder andere door het bereiken van technologische grenzen. De eerste werkende versie van Scala dateert uit 2001, in 2003 is de taal vrijgegeven. Na een flinke herziening in 2006 is Scala stabiel en volwassen geworden. Dit was de versie 2.8. Bekende toepassingen die allang in productie zijn Twitter en LinkedIn.
Platformen en licenties