WikiDer > Scala (Programmiersprache)

Reichweite
Paradigma	Multiparadigma: funktional, Imperativ, Wettbewerber
erschien	2004
Entworfen von	Martin Odersky
Entwickelt von	EPFL - LAMP (École Polytechnique Fédérale de Lausanne - Laboratoire de Méthodes de Programmation)
Aktuelle Version	2.13.2 (22. April 2020)
Typensystem	statisch, stark mit Typinferenz.
Implementierungen	scalac[1] (JVM, LAMPE-EPFL), scalacompiler.exe (.NET, LAMP-EPFL)
Dialekte	Kotlin
Beeinflusst von	Eiffel, Erlang
Einfluss auf	Phantom, Ceylon, Kotlin
Betriebssystem	JVM, .Net-CLR, LLVM
Lizenz	BSD-ish[2]
Dateierweiterungen	.scala, .sc
Webseite	http://www.scala-lang.org/
Portal    Informatik

Reichweite ist ein Objektfunktional Programmierung- und Skriptsprache für allgemeine Anwendungen. Es ist statisch typisiert, entworfen, um Lösungen prägnant auszudrücken, in a typsicher, elegant^[3] und leichte Art. Es integriert die Vorteile von objektorientierten und Funktionsprinzipien. Moderne Softwarekonstruktionen (Schließungen, Monaden^[4], Schwanzrekursion etc.) kann z.B. generisch, Funktionen höherer Ordnung, MustervergleichMehrfachvererbung, Call-by-NameAuswertung etc. Scala läuft auf Javas virtueller Maschine (JVM) und kann einige der Unzulänglichkeiten von Java überwinden (z. B. Mehrfachvererbung von Klassen).^[Quelle?]

Hintergrund

Das Open-Source-Sprache wurde entwickelt und betreut von EPFL (Ecole Polytechnique Fédérale de Lausanne) im Schweiz, Typesafe Inc./Typesafe Switzerland Sàrl und Mitwirkende unter der Leitung von Professor Martin Odersky.^[Quelle?]

In Codezeilen werden Java-Programme normalerweise um den Faktor zwei oder mehr reduziert^[5][6]. Darüber hinaus ist die Position des Codes in den Quelldateien nicht starr, wodurch eine effizientere Struktur verwendet und die Anzahl dieser Dateien reduziert werden kann. Die Verwendung vieler wiederholter Boilerplate-Codes wird in Scala oft verhindert. Java-Programmierer können dies lösen, indem sie Editoren verwenden, die automatisch Boilerplate-Code hinzufügen, aber dadurch wird der Quellcode weniger klar.

Scala ist eine statisch typisierte Sprache. Es Typsystem ist eine der fortschrittlichsten aller Programmiersprachen, auch weil sie die umfassenden Ideen der funktionalen Programmierung und der objektorientierten Programmierung vereint. Das Typsystem versucht umfassend logisch, vollständig und konsistent zu sein. Sein wissenschaftsbasiertes Design überschreitet die Grenzen des Java-Typsystems. Das Typensystem kann einschüchternd wirken, insbesondere für Programmierer, die hauptsächlich mit einer dynamisch typisierten Sprache vertraut sind. Das Typinferenz verbirgt jedoch die meiste Komplexität und ist der Freund des Programmierers.

Die Operation in a Integrierte Entwicklungsumgebung (IDE) kann durch den eingebauten 'Scala Presentation Compiler' als proaktiv erlebt werden. Dieser Compiler überprüft den Quellcode automatisch nach jeder Änderung und verfügt über eine Reihe von Inferenzmechanismen. Diese Mechanismen wirken auf den Code ein, beispielsweise wo das Ende einer Anweisung ist oder über den resultierenden Typ (Typinferenz). Ein einfaches Beispiel für Typinferenz; eine Initialisierung mit 42 gibt das Variable der statische Typ int (integer), eine Initialisierung mit "Hello World!" ist automatisch java.lang.Zeichenfolge typisiert. Dito die Variable, dass eine Funktion ein Ergebnis zurückgibt; Daher erhält die Funktion den Typ dieser Variablen.

Die Typinferenz entlastet den Programmierer von der Überprüfung und wiederholten Neuspezifikation von Typen, sodass sich Scala wie eine dynamisch typisierte Sprache anfühlt mit dem großen Vorteil: Typen werden einmal in der Entwicklungsumgebung zur Kompilierzeit und nicht mehrmals zur Laufzeit ausgewertet. Die ausführbare Datei ist schnell .

Bekannte Java-Entwicklungstools, wie z Finsternis^[7], IntelliJ IDEE^[8] oder NetBeans-IDE^[9], bieten auch Unterstützung für Scala. Obwohl die Byte-Codeinteroperabel mit (vorhandenem) Java-Code ist, trägt Scala nicht die Last vergangener unglücklicher Entscheidungen wie Java.^[10]

Zeitachse	Konzept ${Anzeigestil langer Pfeil nach rechts}$ Einsatz
Technologie	Designzeit	Kompilierzeit	Laufzeit
Konventionell statischer Typ	bearbeiten	Syntaxprüfung ${Schwert im Anzeigestil}$	Ausführung Fehlerüberprüfung ${Schwert im Anzeigestil}$Typprüfung
Bereich IDE	bearbeiten Syntaxprüfung	Typprüfung	Ausführung

Durch Tooling werden Editieren, Kompilieren und Laufzeit von einer herkömmlichen Phase in eine frühere Phase verschoben. Zum Beispiel Fehlerprüfung während der Bearbeitung, Typprüfung, niemals nach der Kompilierungsphase. Dies erzeugt eine schnellere und zuverlässigere ausführbare Datei.

Der Name ist a Komposition skalierbarer Sprache und drückt den sehr kompakten universellen Sprachkern aus, der die Möglichkeit bietet, häufig verwendete Sprachelemente wie zusätzliche Operatoren oder zusätzliche Steueranweisungen in Benutzerklassen zu implementieren und damit die Sprache zu erweitern. Mit anderen Worten, die Sprache ist im Compiler nicht hartcodiert. Es besteht zum Beispiel auch die Möglichkeit, eigene zu erstellen domänenspezifische Sprache erschaffen.

Skalierbar kann in folgenden Bereichen erklärt werden:

1. Scala kann parallel ausgeführt werden und ist in Produktionsumgebungen mit wachsender Anzahl skalierbar Prozessoren. Nicht nur die Möglichkeit, in Scala funktional zu programmieren, macht Scala für parallele Programme geeignet; Scala hat auch eine bessere Alternative für Multithreading mit Java: Schauspieler;
2. Eine Spracherweiterung kann am Sprachkern vorgenommen werden, zum Beispiel in Bibliotheken (z.B. der Unterbrechung Aussage).
3. Scala kann beides sein Imperativ und/oder funktionell genutzt werden;
4. Die Sprache kann sowohl als Quellcode für den Compiler verwendet werden, aber auch aufgrund ihrer Kompaktheit als Skriptsprache für den Interpreter, beispielsweise beim Programmieren oder Testen.
5. Scala-kompilierter Code kann unterschiedlich erstellt werden für Smartphones zu groß Multicore-oder Multiprozessor-Plattformen;
6. Und das auf verschiedenen Plattformen: JVM, CLR (CLR die mobilen Apps ausgeschlossen) und LLVM^[11][12];
7. Umfangreiche Erweiterungen für JVM- und/oder CLR-Bibliotheken;
8. In Scala kann ein DSL-Interpreter (Domain Specific Language) eingebettet werden;

Ein enthaltenes Beispiel für Flexibilität bei der Spracherweiterung ist die XML-Integration. In Bezug auf die Architektur hat es die folgenden vier Sprachmechanismen, die eine skalierbare Zusammensetzung von Systemen fördern: explizite Selbsttypen, Member vom abstrakten Typ und generisch, verschachtelte Klassen und Mixin-Komposition mit Züge.

James Gosling, Mitbegründer der Programmiersprache Java, wurde gefragt, welche andere JVM-Sprache als Java er wählen würde; „Scala“, antwortete er prompt.^[13]

James Strachan, Das Groovig geschaffen hat, beschreibt Scala als möglichen Nachfolger von Java^[14]: "Ich kann ehrlich sagen, wenn mir jemand die "Programmierung in Scala" sagt^[15]Buch von Martin Odersky, Lex Spoon & Bill Venners im Jahr 2003, hätte ich Groovy wahrscheinlich nie gemacht."

Beispiele

Hallo Welt-Befehlszeile

EIN Hallo Welt!Programm in Scala:

ObjektHallo WelterweitertApp{println("Hallo Welt!")}

Im Gegensatz zu den Java-Beispielprogramm es wird keine Klassendeklaration benötigt und nichts wird benötigt, wenn statisch deklariert werden^[16], stattdessen a SingletonObjekt verwendet. Der Einstiegspunkt Main kommt durch die Eigenschaft App eingebracht.

Hello World als Scala-Shell-Skript^[17]

#!/bin/shausführender Rahmen "$0""$@"!#// Hier das Scala-Skriptprintln("Hallo Welt!")// Beliebige Argumente ausgeben args.toList foreach println

::#!@Echo ausAnruf Rahmen %0%*gehe zu:eof::!#println("Hallo Welt!")args.toList für jeden Druckln

Hello World in einer grafischen Benutzerumgebung

Ein Hallo, Welt!GUIProgramm in Scala:

Scala REPL HelloWorld als GUI

importierenschwingen._ObjektHallo WelterweitertSimpleSwing-Anwendung{defoben=NeuMainFrame{Titel="Hallo Welt!"Inhalt=NeuTaste{Text="Klick mich!"}}}

Hallo Welt, .Net-Version

Ein Hallo, Welt!.GeradeProgramm in Scala:

Scala HelloWorld als .Net-Dialog

importierenschwingen._ObjektHelloDotNetWorld{defMain(args:Array[Zeichenfolge]){System.Fenster.Formen.Nachrichtenbox.Show("Hallo, .net-Welt!")}}

Veranschaulichung der Unterschiede zwischen Java- und Scala-Syntax

// Java:intSchwierigeFunktionMitThirdPowerAndLog(intnum){intnumQuadrat=num*num;Rückkehr(int)(Mathematik.cbrt(numQuadrat)Mathematik.Log(numQuadrat));}

// Scala: Eine muttersprachliche Version// Verwendet Typrückschluss, keine Rückgabeanweisung,// verwendet die Methode 'toInt()', ohne KlammernimportierenMathematik._defSchwierigeFunktionMitThirdPowerAndLog(num:int)={fallennumQuadrat=num*num(cbrt(numQuadrat)Log(numQuadrat))toInt}

Hier sind die folgenden Unterschiede zwischen der Syntax:

• In Scala . sein Semikolonist nicht immer erforderlich;
• Großbuchstabe vor dem Datentypen: int, doppelt, Boolesches statt entsprechend int, doppelt, boolesch.
• Datentyp von a Variable, Parameter oder Funktion steht hinter dem Kennung, wie in Pascal, statt vorne;
• Prozedur oder Funktion sind mit dem vorangestellt def Stichwort;
• Eine Funktion oder Methode hat ein =-sign, sonst ist es eine Prozedur (gibt Objekt Einheit zurück);
• Bei Variablen unterscheidet Scala zwischen veränderbaren Variablen (veränderlich) und Festwertvariablen (unveränderlich). Lokalen oder Klassenvariablen muss das Präfix . vorangestellt werden fallen- für ein unveränderliches oder varSchlüsselwort für eine veränderliche Variable;
• Das RückkehrBediener ist nicht erforderlich, aber erlaubt; der Wert der zuletzt ausgeführten Anweisung ist der Rückgabewert und definiert den Typ der Funktion (Typinferenz);
• Anstelle des Java-Cast-Operators (Typ) foo, verwendet Scala foo.asInstanceOf[Typ], aber normalerweise eine spezielle Konvertierungsfunktion wie verdoppeln oder toInt;
• Anstelle der Javas Mathematik importieren*; verwendet Scala Mathe importieren._. Das unterstreichen ist Scalas Platzhalter;
• Infix-Notation: Eine Funktion oder Methodedef foo() kann einfach aufgerufen werden als foo. Methode thread.senden(signo) kann aufgerufen werden als thread senden signo; und Methode foo.toString() kann mit verwendet werden foo toString. Diese Freiheit ermöglicht die Verwendung als domänenspezifische Sprache.

Einige andere grundlegende Syntaxunterschiede:

• ArrayElemente werden beispielsweise als Funktionsaufrufe angesprochen Array(i) Anstatt von Array[i];
• Generische Typen werden zwischen eckige Klammern statt Javas Angelhaken: Liste;
• Anstelle des Pseudotyps Leere hat Scala den Strom? Singleton-ObjektEinheit.

Geschichte der Scala

Scala ist die Idee von Martin Odersky, Professor an der École Polytechnique Fédérale de Lausanne. Sein Ziel war es, wissenschaftliche Forschung in Programmiersprachen zu nutzen, um Java zu verbessern. Aufgrund seines akademischen Hintergrunds hatte er eine Vorliebe für funktionale Programmierung. Einer seiner Beiträge war Java Generics in Java 1.5, nachdem er versucht hatte, Pizza (ein Superset von Java mit einigen Funktionen der funktionalen Programmierung) zu entwickeln.^[18] (Odersky wurde 2011 zum Top Java Ambassador ernannt.^[19]) Während der Arbeit an dieser Erweiterung spürte er die großen Einschränkungen von Java, die seine Ideen durchkreuzten. Von diesem Moment an trat er einen Schritt zurück und begann etwas Neues mit einer sauberen Schiefertafel. Dies jedoch, ohne die vorhandene Infrastruktur – JVM und die Java-Bibliotheken – über Bord zu werfen. Aufgrund eines zu radikalen Ansatzes entstand daraus eine rein theoretische und damit unpraktische Sprache, genannt Funnel. Am Ende begann Scala pragmatisch wieder mit einer Sprache, die irgendwo zwischen akademisch und praktisch liegen musste.

Odersky erkannte früh die Bedeutung funktionaler Programmierung für die Java-Community (zB besser vorhersehbare Performance, Parallelität, Beweisbarkeit der Programmkorrektheit), fand aber damals kein Interesse. Allmählich verbreitet sich diese Erkenntnis immer weiter, unter anderem durch das Erreichen technologischer Grenzen: Die erste funktionierende Version von Scala stammt aus dem Jahr 2001, 2003 wurde die Sprache veröffentlicht. Nach einer Generalüberholung im Jahr 2006 ist Scala stabil und ausgereift. Das war Version 2.8. Bekannte Anwendungen, die schon lange in Produktion sind Twitter und LinkedIn.

Plattformen und Lizenzen

Scala läuft sowohl auf Java- als auch auf .NET-Plattformen. Es wird seinem Namen als skalierbare Sprache gerecht, die auf Smartphones bis hin zu Cloud-Umgebungen ausgeführt werden kann. Obwohl es eine traditionelle Tendenz zur JVM gibt, gibt es keinen Grund dazu. Eine erfolgreiche Implementierung auf der damals (Juni 2004) jungen .NET-Plattform erfolgte relativ schnell mit begrenzten Ressourcen. Es ist tatsächlich eine Herausforderung, auf mehr Plattformen laufen zu können. Dann bekommt das Sprichwort "Einmal schreiben, überall ausführen" eine tiefere Bedeutung, da Scala auch von virtuellen Maschinen unabhängig wird.

Allerdings sind die Ressourcen begrenzt und hier müssen Entscheidungen getroffen werden. Wichtig ist, wie Microsoft - sie haben eine ähnliche Sprache F♯ - Komm damit klar. Werden sie diese haben? Quelloffene Software neben ihnen tolerieren geistigen Eigentums?

Die Scala-Verteilung^[20] Ist enthalten Compiler und Scala-Standardbibliothek veröffentlicht unter BSD-ähnliche Bedingungen mit nur drei Klauseln^[2].

Java-Interoperabilität

Vorhandener Java-Code und Programmiererfahrung sind wiederverwendbar. Scala-Programme laufen auch auf den verschiedenen Java-VMs und deren Byte-Code (Klassendatei) kompatibel mit Java, ermöglicht die vollständige Nutzung vorhandener Java-Bibliotheken oder vorhandener Anwendungscodes (JavaBeans einschließlich). Auch mit Google-Android zum Entwickeln mobile Apps für Mobiltelefone. Aus Scala-Code können die Java-Klassen instanziiert und ihre jeweiligen Methoden aufgerufen werden und aus Java können die Scala-Klassen und -Objekte oft mit ihren Methoden verwendet werden. Die Integration ist oft nahtlos. Ein gutes Beispiel dafür ist der Zeichenfolge Objekt, das in Java immer unveränderlich und daher typsicher war. Aufgrund dieser Eigenschaften wurde es in der Scala-Bibliothek nicht neu definiert und wird sofort referenziert java.lang.Zeichenfolge. Java kann jedoch keine Scala-definierten Merkmale verwenden, da Java dies nicht weiß.

JVM-Entwicklungsumgebungen

Es gibt eine Vielzahl von Entwicklungsmöglichkeiten, von einfach bis fortgeschritten. Sie können auf dem Computer installiert werden, sofern ein JavaJDK Eingerichtet.

Interaktiver Scala-Interpreter (REPL)

Das REPL ist Befehlszeilenschnittstelle-basiertes einfaches, interaktives Standardwerkzeug zum Beispiel für explorative Programmierung. Es ist nützlich, Code zu testen, aber auch zu sehen, was die resultierenden Typen sein werden.
Wenn die Scala-Distribution von Scala-lang.com^[21] installiert, können Sie fortfahren Rahmen in einer Kommandozeilenschnittstelle kann die REPL gestartet werden. Eine REPL ist eine einfache, interaktive Computerprogrammierumgebung und ermöglicht die Verwendung von Scala als Skriptsprache. Es hat eine Tabulator-Vervollständigungsfunktion für Pakete, Klassen und Methoden. In einer solchen interaktiven Scala-Sitzung, nach a Rückkehr der ausgewertete Ausdruck und, falls vollständig und gültig, die angezeigten Ergebnisse.

Einfach Scala ist eine Online-REPL. Für einen schnellen Einstieg in Scala gedacht.

Der Scala Interactive Interpreter oder Scala REPL kommt auch in den verschiedenen IDEs und dem SBT vor. In der IDE heißt es "Scala Interpreter" und im SBT kann es mit dem Befehl geöffnet werden Konsole.

Eclipse für Scala-IDE

Seit 2011 wird die Plug-in-Entwicklung als EPFL/Typesafe-Projekt aufgegriffen. Davor wurde die Entwicklung von einigen von Electricité de France Trading durchgeführt.

Auf typesafe.com eine komplett vorkonfigurierte "Scala IDE for Eclipse"^[22] heruntergeladen werden.

Scala-Dolmetscher im Scala-Projekt

Scala-Arbeitsblatt

IntelliJ IDEE

NetBeans-IDE

Einfaches Build-Tool

Laden Sie die gewünschte Version von SBT herunter.^[23]

Rahmen

-->

.NET-Integration

Scala wurde primär für die Java Virtual Machine entwickelt, mittlerweile gibt es auch Implementierungen für .NET^{[24][25][26][27]}.

Ausgeprägte Sprachkonzepte

Scala ist objektorientiert, in dem Sinne, dass jeder Wert ein Objekt ist. Die Sprache ist auch eine funktionale Programmiersprache in dem Sinne, dass jede Funktion auch ein Wert ist. Scala ist statisch und stark typisiert, genau wie die Programmiersprache Java. Einige andere Sprachen, die auch auf der JVM-Infrastruktur funktionieren, wie z Clojure, Rubin und Groovy, aber auch Python, Javascript und Smalltalk andererseits werden dynamisch typisiert. Seit Scala Version 2.10 gibt es auch a dynamischer Typ verfügbar.

Leichte Syntax und Ausdruckskraft

Die Ausdruckskraft von Sprachen wurde erforscht,^[28] Scala war mit 18 an der Spitze^e qualifiziert. Unten finden Sie eine Lösung für ein Problem in Java (43^e).

importierenjava.util.Iterator;importierenjava.util.Map;ÖffentlichkeitKlasseHefedatei1{ÖffentlichkeitstatischZeichenfolgeconvertPathArgsHashToString(MappePfadArgs){StringBufferpathArgsString=NeuStringBuffer();ZeichenfolgeArgumentWert;boolescherster Lauf=wahr;wenn(PfadArgs!=Null){zum(IteratorargumentIterator=PfadArgs.Schlüsselsatz().Iterator();argumentIterator.hasNext();){ZeichenfolgeStreit=(Zeichenfolge)argumentIterator.Nächster();wenn(erster Lauf){erster Lauf=falsch;pathArgsString.anhängen("?");}sonst{pathArgsString.anhängen("&");}ArgumentWert=(Zeichenfolge)PfadArgs.erhalten(Streit);pathArgsString.anhängen(Streit);wenn(ArgumentWert!=Null){pathArgsString.anhängen("=");pathArgsString.anhängen(ArgumentWert);}}}RückkehrpathArgsString.toString();}/** * @param args */ÖffentlichkeitstatischLeereMain(Zeichenfolge[]args){// TODO Automatisch generierter Methoden-Stub}}

Und habe das gleiche Problem in Scala gelöst:

ObjektHefedatei1aerweitertApp{defconvertPathArgsHashToString(PfadArgs:Mappe[Zeichenfolge,Zeichenfolge])={(wenn(PfadArgs.ist leer)""sonst"?")PfadArgs.Mappe(kv=>kv._1"="kv._2).mkString("&")}println(convertPathArgsHashToString(Mappe()))}

Semikolon-Inferenz

Das Semikolon zur Angabe des Endes einer Anweisung ist in Scala oft überflüssig. Bei mehreren Anweisungen in einer Zeile kann dies wichtig sein, aber dies ist ein unerwünschtes Layout. Die genauen Regeln für die Anweisungstrennung sind einfach.

Ein Zeilenumbruch wird als Semikolon interpretiert, wenn eine der folgenden Bedingungen nicht erfüllt ist:

• Die Betreffzeile endet mit einem Wort, das nicht als Ende einer Anweisung gelten kann, wie z. B. ein Punkt oder ein Infix-Operator.
• Die nächste Zeile beginnt mit einem Wort, das nicht der Anfang einer Anweisung sein kann.
• Bei einer Aussage mit Klammern (…) oder […] endet die Zeile dazwischen.

Ein Programmierer muss dies nicht wissen, in der IDE gibt es eine Schaltfläche zum Anzeigen der Inferenz-Semikolons.

Um eine lange Anweisung zu unterbrechen, ist es sinnvoll, einen Operator in der vorherigen Zeile zu belassen.

Typinferenz

sehen Typinferenz für den Hauptartikel zu diesem Thema.

Typrückschluss oder implizite Typisierung ist die Fähigkeit einer Programmiersprache wie Scala, den Typ eines Ausdrucks automatisch abzuleiten.

Operatornotation infixieren not

Bei Scala gibt es die Möglichkeit, Objektinstanzname.method(par1, ...)-Notation zu verlassen und ein entspanntes Infix-Notation benutzen. Die Infix-Notation bedeutet, dass die Methode zu einem Operator wird, da sie zwischen den Operanden platziert wird.

Xfoo/*ist Infix-Notation für*/X.foo();Xfooja/*ist Infix-Notation für*/X.foo(ja);ja::X/*ist Infix-Notation für*/X.::(ja);// Doppelpunkt vertauscht die OperandensoIndex von('Ö',5)/*ist Infix-Notation für*/so.Index von('Ö',5)// aber auch72/*ist Infix-Notation für*/7.(2)// Wo ist eine Methode

Daher sind die üblichen Operatoren ( , -, *, / usw.) in der Standardbibliothek definiert und nicht im Compiler fest codiert, was sowohl die Sprache als auch den Compiler leichter macht Objektinstanzname.method(par1, ...) Notation weiterhin verwendet werden kann, hat die Infix-Notation folgende Vorteile:

• Der Quellcode wird klarer, wenn das "Rauschen" von Punkten und Klammern verschwindet.
• Es ist plötzlich möglich, Operatoren selbst (neu) zu definieren.
• Programmgesteuert definierte Operatoren ist es möglich, eine neue (DSL-)Sprache zu erstellen.
• Die Operatoren sind kein Sprachelement mehr, sondern wandern in die Standardbibliothek. Dies macht den Compiler leichter.

Für Iterationen (zum Verständnis)

sehen Sequenzbewusstsein für den Hauptartikel zu diesem Thema.

Es für Schleife-Anweisung ist ein wesentliches Softwarekonstrukt. Bei der Anwendung kommt es auf Effizienz an, da die Bearbeitungszeit durch die häufige Wiederholung erhöht wird. Scala bietet das sogenannte For-Verständnis, bei dem For-Schleifen in eine funktionale Version umgewandelt werden. Neben einer recht effizienten Konstruktion mit Funktionen höherer Ordnung mit Tail-Rekursion kann auch ein Geschwindigkeitsgewinn durch parallele Verarbeitung erfolgen.

Sequenzbewusstsein (englischer Begriff: For-comprehension) ist eine wichtige Operation des Compilers, um als for-Schleifen geschriebene Anweisungen in ein Konstrukt umzuwandeln, das schließlich eine neue Sammlung generiert, die von einer Sammlung gesteuert wird. Die for-Schleife wird somit in eine generierte Liste (Listengenerator), ggf. eine Filterfunktion und eine Collection-to-Collection-Funktion umgewandelt:

// Original skalieren:zum{ich<-1bis umneinja<-1bis umich// ^wennisPrime(ichja)// | Block A}Ausbeute(ich,ja)// |

// Vom Compiler konvertiert 1. Strich:////(1bis umnein)flatMap(ich=>zum(ja<-(1bis umich)wennisPrime(ichja))Ausbeute(ich,ja))// <-------- Block A --------->

// Konvertiert vom Compiler 2. Strich://(1bis umnein)flatMap(ich=>(1bis umich).mitFilter(ja=>isPrime(ichja)).Mappe(ja=>(ich,ja)))

In Wirklichkeit drückt der Scala-Compiler die for-Ausdrücke in Form von map, flatMap und a . aus faule Variante einer Filterfunktion. Diese Version mit höherwertigen Funktionen lässt die klassische(n) Zählervariable(n) - die einen Nebeneffekt hätte - verschwinden und es sind somit verschiedene Optimierungen möglich, zB Parallelverarbeitung. Für die Programmierer ist es oft von Vorteil, dass sie die gewünschte Verarbeitung noch in einer for-Schleife ausdrücken können; es sieht durch die Analogie mit der mathematischen Notation verständlicher aus, so etwas wie ∀nein ∈ n: nein² ist eben. Es kann auch gesagt werden, dass diesSQL-) abfrageähnliche Darstellung Kurz gesagt bietet das for-Sprachelement eine alternative und praktischere Möglichkeit, etwas in einer vertrauten Notation zu schreiben. Das wird sein syntethischer Zucker erwähnt.

Robustheit

Das einheitliche Typensystem

Bereichsvereinheitlichte Typenhierarchie

In einer nicht vereinheitlichten Typsystemsprache wie beispielsweise Java unterscheidet man klar zwischen primitiven Typen (wie z int, verkohlen und boolesch) und Referenztypen (beliebige Klasse). Nur Referenztypen können Teil einer hierarchischen Klassenstruktur sein. In Scala hingegen, wo alles ein Objekt ist, erben alle Typen von einer Klasse der obersten Ebene irgendein, deren unmittelbare Kinder AnyVal (Werttypen wie Byte, kurz, int, Lunge, doppelt, schweben und Einheit, Boolesches, Verkohlen) und AnyRef (Referenztypen, zum Beispiel: Zeichenfolge, das ist ein Pseudonym java.lang.Zeichenfolge und alle anderen (Java-)Klassen). Dies bedeutet, dass Javas Unterscheidung zwischen primitiven Typen und geschachtelten Typen (z. int gegen Ganze Zahl) sind in Scala nicht vorhanden, Boxen und Unboxing ist für den Benutzer völlig transparent und der Compiler optimiert auf JVM-Primitive.

Einheit ist Scalas Leere, es ist ein Singleton-Typ, also mit nur einem instanziierten Objekt. Mit Scala 2.10 wird es möglich sein, neue Werttypen zu definieren. (Dies war bisher nicht möglich, da die versiegeltStichwort wird in der Laufzeitbibliothek verwendet.) Am Ende nichts Subtyp aller Klassen, jedoch ohne Vererbung. nichts ist immer das Ergebnis von a Ausnahme.

Optionsobjekt

Wenn in Scala bekannt ist, dass die Methode manchmal keinen Wert zurückgibt, kann object . verwendet werden Möglichkeit, dass die Klasseetwas oder Objekt keiner zurückkehren kann. (Objekte sind einmalige Instanzen einer Klasse.) Beispiel:

defComputeFoo:Möglichkeit[foo]={...}

Beachten Sie den Rückgabetyp "Option of Foo".

ComputeFooWettbewerb{Falletwas(foo)=>...// hat einen Foo, mach etwas damitFallkeiner=>...// habe Foo nicht bekommen, kümmere dich darum}

Das macht die unglückliche Wahl^[29] mit Nullwerten und auch defensive Programmierung vermieden. Alle Scala-Klassen sind übrigens Unterklassen von irgendein und ist nichts ein Untertyp aller Scala-Klassen. Der Nullwert ist weiterhin für die Java- und .NET-Integration erforderlich. Es ist Typ Rahmen.Null und daher kompatibel mit jedem Referenztyp.

Objektorientierung

Scala ist eine rein objektorientierte Sprache in dem Sinne, dass jeder Wert ein Objekt ist. Objektdatentypen und -verhalten werden durch Klassen und Merkmale beschrieben. Klassen können mit Klassenabstraktionen und durch einen flexiblen und problemlosen Mixin-basierten Kompositionsmechanismus mit Mehrfachvererbung erweitert werden.

Klassen und Objekte

Scala hat keine statische (gekennzeichnet durch statisch) Variablen oder Methoden. Stattdessen verfügt es über Singleton-Objekte, bei denen es sich im Wesentlichen um Klassen mit nur einer einmaligen Instanz handelt. Singletons werden mit . deklariert Objekt Anstatt von Klasse. Es ist gängige Praxis, eine Klasse mit demselben Namen zu erstellen und die Methoden und statischen Variablen in das sogenannte Begleitobjekt zu legen. Eine Klasse hat Zugriffsrechte auf alle Variablen und Methoden des Begleitobjekts, auch wenn diese privat sind und umgekehrt.

Abhängigkeitsspritze

Mehrfachvererbung mit Traits

Eigenschaften sind Scalas Ersatz für Java-Schnittstellen. Schnittstellen in Java sind sehr eingeschränkt, in ihnen können nur abstrakte Funktionen deklariert werden. Außerdem müssen die gleichen Methoden bei der Anwendung erneut implementiert werden. Eigenschaften sind ähnlich wie mischenKlassen in dem Sinne, dass sie fast alle Fähigkeiten regulärer konkreter Klassen besitzen, jedoch ohne Klassenparameter (das Äquivalent von Scala zu Java-Konstruktorparametern), da Traits immer mit einer konkreten Klasse verbunden sind. Das SuperDer Operator verhält sich insbesondere in Merkmalen, sodass Merkmale zusätzlich zur Vererbung durch Komposition verbunden werden können.

Raumschiff	Bewaffnet	Rüstung	Medizin
Schlachtschiff
Kommandoschiff
Schlachtschiff
Unterstützungsschiff

ObjektKrieg der Sterne{KlasseSchiff(varGesundheit:int=0){defschlagen=Gesundheit-=2defrepariert(wie gut:int){Gesundheit =wie gut}}MerkmalGewehr{defFeuerAt(so:Schiff)=so.schlagen}MerkmalMedizin{}MerkmalSchild{selbst:Schiff=>überschreibendefschlagen=selbst.Gesundheit-=1}MerkmalReparatur{defReparierwerkzeug(so:Schiff,Qualität:int)=so.repariert(Qualität)}fallenimperialKämpfer=NeuSchiff(10)mitGewehrfallenimperialRepairShip=NeuSchiff(10)mitReparaturmitMedizinfallenrebelKämpfer=NeuSchiff(10)mitGewehrimperialKämpfer.FeuerAt(rebelKämpfer)println(rebelKämpfer.Gesundheit)}

Oft von Merkmals einfach mächtige (generische) Methoden geerbt. Ein Beispiel dafür ist die Methode scala.collection.Traversable.mkString für schnelle formatierte Ausgabe. Dies funktioniert auf einer ganzen Reihe von Strukturen aus der Sammlungsbibliothek.

Funktionale Programmierung

Bei der funktionalen Programmierung werden die Programme durch die Auswertung von Ausdrücken ausgeführt, anders als bei der imperativen Programmierung, bei der Programme aus Anweisungen bestehen, die bei der Ausführung den globalen Zustand ändern. Funktionale Programmierung vermeidet die Verwendung veränderlicher Variablen und destruktiver Neuzuweisungen, auch bekannt als Nebenwirkungen. Scala bietet umfassende Unterstützung für funktionale Programmierung von der Ausstattung Curry, Musterabgleich, algebraische Datentypen, faule Bewertung, Schwanzrekursion, Unveränderlichkeit usw. In Scala sind Funktionen "erster Klasse", dh jede Funktion ist ein Wert. Dadurch können sie wie Werte verwendet werden: als Argumente für andere Funktionen oder als Ergebnis einer Funktion zurückgegeben. Diese Austauschbarkeit ist bekannt als referenzielle Transparenz und erfordert auch, dass die Funktionen keine Nebenwirkungen haben. Die Verwendung von Funktionen als Argumente wird häufiger als Funktionen höherer Ordnung bezeichnet, und die Rückgabe von Funktionen macht Funktionen unter anderem zuCurry möglich. Scala hat eine einfache Syntax zum Definieren anonyme Funktionen, es unterstützt Funktionen höherer Ordnung und Currying und erlaubt verschachtelte Funktionen. Es unterstützt Mustererkennung oder Mustervergleich. Pattern Matching kann in der XML-Verarbeitung verwendet werden, die auch in Scala unterstützt wird.

Funktionen

Alles ist ein Ausdruck. Im Kontrast zu C oder Java, aber ähnlich zu Sprachen wie lispeln, Scala unterscheidet nicht zwischen Anweisungen und Ausdrücken. Alle Anweisungen sind tatsächlich Ausdrücke, die zu einem Wert ausgewertet werden. Funktionen, die als . deklariert werden könnten Leere in C oder Java und Ausdrücke, die keinen Wert zurückgeben (z. B. eine Zuweisung Fallwert = 42) Ergebnis in Scala zu tippen Einheit. Funktionen und Operatoren, die logischerweise nichts zurückgeben konnten (z. B. die werfenOperator oder eine Funktion, die nicht lokal von einer Ausnahme abgefangen wird) erhält immer noch den Rückgabetyp nichts, ein spezieller Typ, der keine Unterobjekte hat und der absolute unterste Typ ist, d. h. eine Unterklasse aller möglichen Typen. So, nichts kompatibel mit jedem Typ. Dadurch kann der Typinferenzmechanismus weiterhin vollständig funktionieren.

Auch ein wenn-dann-sonst-Anweisung ist eigentlich ein Ausdruck, der einen Wert zurückgibt, d. h. das Ergebnis der Auswertung eines von zwei Zweigen:

// Java:inthexDigit=X>10?X'EIN':X'0';

// Reichweite:fallenhexDigit=wenn(X>10)X'EIN'sonstX'0'

Das bedeutet, dass ein solcher Codeblock überall dort eingefügt werden kann, wo ein Ausdruck gewünscht wird. Aus den gleichen Gründen, Rückkehr-statements onnodig in Scala en het gebruik ervan wordt zelfs ontmoedigd. Net als in Lisp is de laatste expressie in een codeblok de waarde van dat blok en als dat blok de body van de functie dan is het deze waarde die wordt teruggegeven.

Voor functies die Unit teruggeven, wordt vanwege dat ze een neveneffect hebben met bepaalde conventie genoteerd:

defprintValue(x:String){println("I ate a %s".format(x))}

Merk op dat een =-teken hier ongewenst is omdat de functie met =-teken bijna onopgemerkt zou kunnen veranderen van return-type. Dit kan voorkomen worden bij deze expliciete notatie:

defprintValue(x:String):Unit={println("I ate a %s".format(x))}

Patroonvergelijking

Een implementatie van het Quicksort-algoritme (illustratief omdat sortering ook in de Scala Standard Library-API kan worden aangeroepen):

// Sjabloon voor generieke sortering mits het sorteerbaar "[A <% Ordered[A]]" isdefquickSort[A<%Ordered[A]](xs:List[A]):List[A]=xsmatch{caseNil=>xs// lege lijst, geef lege lijst terugcasepivot::lijst_zonder_kop=>// ontbonden lijst met de fragmenten kop en staartlijst_zonder_koppartition(_<pivot)// splits de lijst in twee lijstenmatch{case(onder,boven)=>quickSort(onder)(pivot::quickSort(boven))}}

Parallel programmeren

Collections

Basis traits overerving Scala Collections

Scala komt met een rijke native of run-time-standaardbibliotheek waarin ook een goed ontworpen Collectionsframework is opgenomen.

Mutable en Immutable Collections

Er wordt systematisch onderscheid gemaakt tussen wijzigbare (mutable) en onveranderlijke (immutable) collections.^[30] Een muteerbare collectie kan worden bijgewerkt of uitgebreid. Onmuteerbare collecties kunnen daarentegen niét worden gewijzigd, er zijn wel operaties die toevoegen, wissen of bijwerken maar deze operaties zullen altijd een nieuwe collectie opleveren terwijl de oude collectie ongewijzigd blijft. De respectieve pakketten van de collecties zijn scala.collection.mutable en scala.collection.immutable. Bij ontstentenis van deze aanduiding wordt vaak de immutable versie gebruikt. Er zijn ook collecties van het pakket scala.collection, maar die kunnen sommige operaties overgeërfd hebben van scala.collection.mutable, hetgeen een neveneffect kan veroorzaken. De scala.collection.immutable-versies geven de garantie hier geen last van te hebben.

Actors

Met de komst van multicoreprocessors wordt concurrent programming steeds onmisbaar. Scala's primaire concurrency-oplossing is met Actors. Actors zijn in principe gelijktijdige processen die communiceren door berichten uit te wisselen. Actoren kunnen ook worden gezien als een vorm van actieve objecten waarbij het uitvoeren van een methode veroorzaakt is door verzenden van een bericht.

API-verfijning en -overbrugging

Een veelgebruikte techniek in Scala, in kleurrijk taalgebruik bekend als "Pimp my Library"^[31], maakt het mogelijk nieuwe methoden te gebruiken alsof ze werden toegevoegd aan bestaande typen. Dit is conceptueel vergelijkbaar met het C♯-begrip extension methods maar krachtiger, omdat de techniek niet is beperkt tot het toevoegen van methoden, maar kan bijvoorbeeld ook worden gebruikt om nieuwe interfaces implementeren. In Scala, waarbij deze technisch een impliciete conversie wordt van het ontvangende type en de methode voor een nieuw type (gewoonlijk een klasse) de oorspronkelijke type omwikkelt voorzien van bijkomende methoden. Als een methode niet kan worden gevonden voor een bepaald type, zal de compiler automatisch zoeken naar toepasselijke impliciete conversies voor dat geval. Deze techniek maakt het mogelijk dat nieuwe methoden kunnen worden toegevoegd aan een bestaande klasse met behulp van een add-on-bibliotheek, zodat alleen code die de add-on-bibliotheek importeert de nieuwe functionaliteit geeft en alle andere code niet wordt aangetast.

Impliciete typeconversie

Impliciete typeconversie is een operatie van de compiler die een gegeven van een bepaald gegevenstype automatisch converteert naar een ander gegevenstype. In Scala worden de conversiefunctie voorzien van het sleutelwoord implicit. Hierdoor ontstaat er een functie die bijvoorbeeld type A omzet naar type B. Als er in een expressie een gegeven type A is terwijl een type B zonder expliciete methode gevraagd wordt dan zal voordat de compiler een foutmelding geeft, gezocht worden naar met implicit gelabelde functies die de functie heeft om A naar B om te zetten. Is de functie niet gevonden dan meldt de compiler alsnog de fout. Het zoeken naar de functie gebeurd in een beperkt kader. Bijvoorbeeld:

objectMeasurementUnit{valmiFactor=.254traitDistanceimplicitdefinch2meter(x:Inch)=newMeter(x.value*miFactor)implicitdefmeter2inch(x:Meter)=newInch(x.value/miFactor)caseclassMeter(valvalue:Double)extendsDistance{// Presentatie als een String met eenheidsymbooloverridedeftoString=value.toString'm'// Hiermee kunnen de lengtes opgeteld wordendef (m:Meter)=newMeter(valuem.value)}caseclassInch(valvalue:Double)extendsDistance{// Presentatie als een StringoverridedeftoString=value.toString'"'def (m:Inch)=newInch(valuem.value)}defmain(args:Array[String]):Unit={// Engelse duim gegeven, meter gevraagdvalmeter:Meter=Inch(1)// Aut. conversie met inch2meter// Meter gegeven, Engelse duim gevraagdvalinch:Inch=Meter(1)// Aut. conversie met meter2inchvaltotaal:Meter=inchmeterprintln(Inch(1)" = "meter)println(Meter(1)" = "inch)}}

Testen

Er zijn verschillende mogelijkheden om in Scala te testen:

• ScalaTest ondersteunt meerdere teststijlen en kan geïntegreerd worden met Java-gebaseerde frameworks (bijv. JUnit4).
• ScalaCheck, een bibliotheek gelijk aan Haskell's QuickCheck
• specs2, een bibliotheek voor executable-softwarespecificaties.
• ScalaMock voorziet in een mogelijkheid hogereorde en curried functions te testen.
• JUnit of TestNG, de populaire test-raamwerken in Java.

Zakelijke aspecten

Businessmodel

De ontwikkeling van de taal werd onder leiding van Martin Oderski gedaan op de EPFL met zijn programmeeronderzoeksgroep LAMP (Laboratoire de Méthodes de Programmation). Omdat het opensourcesoftware is, kan in principe hier ieder aan meewerken. Het werk is voor een deel wetenschappelijk met name de syntaxis en compilerbouw. Ook wordt er universitair onderricht meegegeven op zijn faculteit. Promovendi nemen deel aan aanpalende onderzoeken voor hun proefschrift.

• Begin 2011 kon Odersky door een vijfjarige subsidie van de European Research Council, groot 2.3 miljoen euro,^[32][33] zijn plannen grootser uitvoeren. Dit was ook aanleiding de commerciële activiteiten onder te brengen in een nieuwe onderneming: Typesafe Inc. als opvolger van Scala Solutions.^[34] Dit bedrijf is opgericht door Martin Odersky, voor zijn Scalabelang, samen met de Zweed Jonas Bonér, bedenker van de middleware Akka voor distributed computing.^[35] Tezamen met het Franse web-framework Play! hebben ze een commercieel platform dat het ook mogelijk maakt geld van investeerders aan te trekken. Het is een strategische keuze geweest om met deze combinatie van opensourceaanbieders samen te werken, alleen valt de Liftweb-aanbieder David Pollak, die Scala sinds 2006 al Scala beoefent, hierdoor buiten de boot. Waarschijnlijk omdat voor hem geen Europees geld gegund wordt.^[bron?]
• Ook in hetzelfde jaar investeert Microsoft ontwikkelingsgeld om Scala op het .NET-platform te kunnen gebruiken.
• In mei 2011 investeert Greylock Partners (Reid Hoffmann (LinkedIn, Airbnb), Chamath Palihapitiya (Facebook); Diane Greene en Mendel Rosenblum (VMWare-oprichters); Francois Stieger (voormalig Verisign-executive); en Jeff Huber (Google)) $ 3 miljoen in het bedrijf.
• In 2012 maakte Typesafe een financiering rond van $ 14 miljoen. Geldschieters zijn Shasta Ventures en Juniper Networks samen met Greylock Partners.

Door een betere bemensing, als gevolg van een betere financiële basis, kon ook de verdere ontwikkeling van aanpalende software serieus ter hand worden genomen, de Integrated Development Environment kon verbeterd worden: er kwam een stabiele versie.

Als adviseurs van Typesave Inc. zijn toegetreden:

• James Gosling, ontwerper van Java;
• Doug Lea, onder andere voorzitter van de Javacommissie die het "Fork/Join Framework" (JSR-166) heeft geïmplementeerd;
• Willy Zwaenepoel, hoogleraar op het EPFL;
• Guillaume Bort, voormalig J2EE-expert en leider van het Play!-opensourceproject.

Op 30 september 2012 treedt Rod Johnson toe tot de directie van Typesafe,^[36] auteur van Expert One-on-one J2EE Development^[37], die het Spring Framework heeft geëntameerd.

Populariteit van Scala

Indeed

Volgens Indeed Job Trends, neemt voor Scala de arbeidsvraag snel toe sinds 2010.^[38]

RedMonk Programming Language classificering

In de RedMonk Programming Language-classificering - die gebruikmaakt van populariteit in Stackoverflow en GitHub - blijft Scala duidelijk achter op een eersterangsgroep van 11 talen (waaronder Java, C, Python, PHP en Ruby), maar leidt de tweede echelongroep, met een voorsprong op Haskell, Groovy, Clojure, Erlang, Prolog, Scheme en Smalltalk.

ThoughtWorks

De ThoughtWorks Technology Advisory Board heeft Scala in haar Radarrapport van oktober 2012 van de Trial- naar de Adopt-ring geadviseerd.^[39] Dit betekent dat Scala als een betrouwbaar volwassen taal beschouwd mag worden en heden ten dage gebruikt kan worden.

TIOBE-index

Rangvolgorde sinds 2006.

In april 2013 zette de programmeertaalpopulariteitsindex TIOBE Scala op de 29e plaats met 0.336% van de totale programmeertalen, terwijl daarvoor lange tijd Scala nog rond de 45 lag. Scala kwam zo in de buurt van Scheme (27e) en voorbij Erlang (31e), Prolog (30e) en Haskell (32e). Scala heeft een ruime voorsprong op zowel Groovy en Clojure, de andere twee JVM-gebaseerde talen die vaak met Scala wordt vergeleken, maar die vallen beiden beneden de 50e plaats.

Transparent Language populariteitsindex

Evenzo zet de Transparent Language-populariteitsindex Scala op positie 34, na Haskell en vóór ML en Erlang.

Enkele bedrijven die Scala gebruiken

Veel bestaande bedrijven die van Java afhankelijk zijn voor bedrijfskritische applicaties wenden Scala aan om hun ontwikkelingsproductiviteit, applicatieschaalbaarheid en betrouwbaarheid te verhogen. Met reactief programmeren worden zware claims op het gebied van responsiviteit, veerkracht, elasticiteit en berichtgedrevenheid toch gerealiseerd.

Appjet heeft voor het succesvolle EtherPad het onderliggende Appjet web raamwerk in Scala ontwikkeld. Appjet is overgenomen voor het Google Wave project wat op zijn beurt deels is opgegaan in het Google Drive project. Google Drive heeft ongeveer de enige web-gebaseerde woordprocessor waarbij meerdere personen tegelijkertijd een document kunnen bewerken waarbij de veranderingen voor iedereen zichtbaar zijn. Een knap staaltje Functioneel Reactief Programmeren.
In april 2009 maakte Twitter bekend dat het belangrijke delen van Ruby naar Scala had omgeschreven en van plan was dat ook met de rest te doen.^[64][65]
LinkedIn gebruikt het Scalatramicroframework om hun Signal API aan te sturen.^[48]
GridGain biedt Scala-based DSL for cloud computing aan.^[45]
Foursquare gebruikt Scala en Lift Web Framework.^[43]
Meetup gebruikt Unfiltered toolkit voor real-time APIs.^[55][56]
In april 2011 maakte The Guardian (guardian.co.uk) bekend dat het overschakelde van Java naar Scala, met als eerste project de Content API voor het selecteren en verzamelen van nieuws content^[62][63]. Deze website heeft de meeste lezers op de New York Times na.^[78]
De Zwitserse bank UBS heeft Scala goedgekeurd voor gebruik in algemene productie.^[76]
Remember the Milk gebruikt Unfiltered toolkit, Scala and Akka voor hun publieke API en real time updates.^[61]
Op 31 augustus 2013 wordt bekendgemaakt dat Intel een gloednieuw gedistribueerd platform bouwt op Scala gebaseerd om zodoende gebruik te maken van de krachtige functies om elegante API's te bouwen. Intel maakt hevig gebruik van instrumenten zoals de Akka concurrency toolkit, die helpt bij het oplossen van een aantal van de inherente problemen met gedistribueerde systemen.^[70]

Kritiek op Scala

Stephen Colebourne - de ontwikkelaar van de alom geroemde Joda-Time-Java-bibliotheek en hoofdontwikkelaar van de JSR-310 Date and Time-API - is de prominente criticus van Scala. Op 29 november 2011 schreef hij over een uitgelekt mailtje tussen een Yammer-personeelslid en mensen van Typesafe dat Yammer weer terug zou switchen naar Java.^[79][80] Hijzelf en het bedrijf haastte zich om nadere uitleg te geven.^[81][82] Het bleek een misverstand. Yammer had een performance-probleem en werd niet onmiddellijk op haar wenken bedient met een "quick fix". Typesafe stond op het standpunt de bug structureel op te lossen en niet ad hoc, verder gaven ze een serieus en inhoudelijk antwoord.^[83]

Trivia

• Scala is Italiaans voor trap. In het aanvankelijke en huidige logo is de rode wenteltrap verwerkt van de faculteit LAMP van de EPFL. Mogelijk is deze trap eveneens de aanleiding voor de naam Scala.
• Martin Odersky was tot in het voorjaar van 2011 een fervent Emacsgebruiker. Hij is overgestapt na het uitkomen van een stabiele Eclipse-IDE voor Scala.
• Op 18 september 2012 begon de eerste 7-weekse MOOC "Functional Programming Principles in Scala" van Coursera.org^[84] met circa 50.000 inschrijvingen waarvan 9593 al hun opdrachten hebben ingestuurd. Op een afsluitende enquête waren er 166 respondenten uit Nederland en 113 uit België. Naar schatting zijn er zo'n 230 studenten in Nederland en 160 in België die al hun opdrachten hebben ingestuurd en beloond zijn met een certificaat.
• De resultaten van de enquête^[85] zijn in een GitHub-repository opgeborgen, samen met het analyserende programma in Scala.^[86]

Zie ook

Categorie:Software geschreven in Scala

Externe links

Officiële website

• (en) Introducing Scala. The Scala Programming Language. Geraadpleegd op 11 maart 2013.
  • (en) Scala Documentation. Geraadpleegd op 1 december 2014.

Typesafe, het commerciële Scala instituut

• (en) Scala the language. Typesafe Platform. Geraadpleegd op 1 december 2014.

Cheat sheets

• (en) O'Connor, Brendan, Scalacheat. Scala Documentation. Geraadpleegd op 6 januari 2013.
• (en) Rytz, Lukas, Scala Cheat Sheet. Github Repository. Geraadpleegd op 29 januari 2013.
• (en) Spiewak, Daniel; David Copeland, Scala Style Guide. Scala Documentation. Geraadpleegd op 8 februari 2013.

Gratis Scalacursussen

• (nl) Stuurman, Sylvia, Opener cursus Scala. Open Universiteit (21 juli 2011). Geraadpleegd op 15 december 2012.
• (de) Paggen, Marcel, ScalaTutorial.de (28 februari 2013). Geraadpleegd op 11 maart 2013.
• (de) Schäfer, Simon, Scala Tutorial. Scala Tutorial (6 april 2012). Geraadpleegd op 28 januari 2013.
• (en) Jenson, Steve; Marius a. Eriksen, Larry Hosken, Scala School!. Geraadpleegd op 17 december 2012.
• (fr) Einstein , Apprenez la programmation avec Scala. Le Site du Zéro (8 januari 2013). Geraadpleegd op 16 december 2012.