Brontekst bekijken van Scala (programmeertaal)

{{Infobox programmeertaal
| naam = Scala
| logo = Scala-full-color.svg
| paradigma = [[Multi-paradigmaprogrammeertaal|Multi-paradigma]]: [[Functionele programmeertaal|functioneel]], [[Imperatief programmeren|imperatief]], [[Concurrent computing|concurrent]]
| jaar = 2004 <!-- 2004-01-20 -->
| ontwerper = [[Martin Odersky]]
| ontwikkelaar = [[Technische Hogeschool van Lausanne|EPFL]] - LAMP (École Polytechnique Fédérale de Lausanne - Laboratoire de Méthodes de Programmation)
| versie = {{wikidata|property|reference|edit|P348}}<br><small>{{wikidata|qualifier|P348|P577}}</small>
| typesystem = statisch, sterk met type&#8209;inferentie.
| implementaties =
[[scalac]]<ref>{{Citeer web
| last = Scala Team
| taal = en
| title = Scala Development Tools
| work = The Scala Programming Language
| accessdate = 2013-04-12
| date = 2011
| url = http://www.scala-lang.org/docu/files/tools/index.html#basic
}}</ref> (JVM, [[LAMP-EPFL]]), scalacompiler.exe (.NET, LAMP-EPFL)
| dialecten =[[Kotlin (programmeertaal)|Kotlin]] 
| beinvloed = [[Eiffel (programmeertaal)|Eiffel]], [[Erlang (programmeertaal)|Erlang]]|, [[Haskell (programmeertaal)|Haskell]],<ref>{{Citeer web |taal=en|url=http://blog.fogus.me/2010/08/06/martinodersky-take5-tolist/ | title=MartinOdersky take(5) toList|last=Fogus|first=Michael| date=2010-08-06|work=Send More Paramedics | accessdate=2012-02-09}}</ref> [[Java (programmeertaal)|Java]], [[Lisp (programmeertaal)|Lisp]]<ref name="Scala Macros">{{Citeer web | url=http://scalamacros.org |taal=en| title=Scala Macros}}</ref>, Pizza<ref name="overview">{{Citeer web
| taal=en| publisher = École Polytechnique Fédérale de Lausanne
| achternaam = Odersky| voornaam = Martin| auteurlink=Martin Odersky
| coauthors = Altherr Philippe, Vincent Cremet, Iulian Dragos, Gilles Dubochet, Burak Emir, Sean McDirmid, Stéphane Micheloud, Nikolay Mihaylov, Michel Schinz, Erik Stenman, Lex Spoon, Matthias Zenger
| title = An Overview of the Scala Programming Language (2. Edition)
| accessdate = 2013-02-18
| date = 2006
| formaat=PDF
| url = http://infoscience.epfl.ch/record/85634
}}</ref>, [[ML (programmeertaal)|Standard ML]], [[OCaml]], [[Scheme]], [[Smalltalk (programmeertaal)|Smalltalk]]| invloed = [[Fantom (programmeertaal)|Fantom]], [[Ceylon (programmeertaal)|Ceylon]], [[Kotlin (programmeertaal)|Kotlin]]
| besturingssysteem = [[JVM]], [[Common Language Runtime|.Net CLR]], [[LLVM]]
| extensies = {{wikidata|properties|P1195}}
| licentie = [[BSD-licentie|BSD]]-achtig<ref name="licentie">[http://www.scala-lang.org/downloads/license.html Scala License]</ref>
| website = {{wikidata|property|P856}}]
}}
'''Scala''' is een object-functionele [[programmeertaal|programmeer]]- en [[scripttaal]] voor algemene toepassingen. Het is [[Typesysteem#Statische typering|statisch getypeerd]], ontworpen om oplossingen bondig uit te drukken, op een [[Typesysteem#Safe en unsafe typing .28veilige en onveilige typering.29|type-veilige]], elegante<ref>{{Citeer web
| last = Brandon Seibel
| title = Scala, so elegant
| work = Making It Scale
| accessdate = 2014-02-03
| url = http://www.makingitscale.com/2012/scala-so-elegant.html
}}</ref> en lichtgewichte wijze. Het integreert de voordelen van [[objectgeoriënteerd]]e en [[Functioneel programmeren|functionele principes]]. Moderne software-constructies (closures, [[Monad (Programmeerconcept)|monaden]]<ref>{{Citeer web
| taal=en
| last = Emir
| first = Burak
| title = Monads in Scala
| work = Laboratoire de Méthodes de Programmation
| accessdate = 2013-05-14
| date = 2006-10-11
| url = http://lampwww.epfl.ch/~emir/bqbase/2005/01/20/monad.html
}}</ref>, [[staartrecursie]] etc.) kunnen opgezet worden met bijvoorbeeld [[genericiteit]], [[hogere-ordefunctie]]s, [[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).{{Bron?|Waaruit blijkt dat dit een "tekortkoming" is?|2015|03|20}}
{{Inhoud links|klein}}

== Achtergrond ==
De [[opensourcesoftware|opensource]]taal is ontwikkeld op en wordt onderhouden door het [[Technische Hogeschool van Lausanne|EPFL]] (École Polytechnique Fédérale de [[Lausanne (stad)|Lausanne]]) in [[Zwitserland]], [[Typesafe Inc.]]/Typesafe Switzerland Sàrl en bijdragers onder leiding van hoogleraar [[Martin Odersky]].{{Bron?||2015|03|20}}

In regels code worden Java-programma's meestal met een factor twee of meer gereduceerd<ref>{{Citeer web
| last = Odersky
| first = Martin
| lang= en
| title = Scala eXchange opening. (slide 8 and following)
| location = London
| accessdate = 2014-04-13
| date = 2011-06-15
| url = http://www.slideshare.net/Odersky/scala-exchange-opening
}}</ref><ref>{{Citeer web
| title = Phone mnemonics
| accessdate = 2014-04-13
| url = http://scalagwt.github.io/samples/Mnemonics.html
}}</ref>. 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 voornamelijk bekend 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 (getal)|42]] geeft die [[Variabele (informatica)|variabele]] het statische type '''Int''' (integer), een initialisatie met "Hello World!" is automatisch <code>java.lang.'''String'''</code> 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 (software)|Eclipse]]<ref>{{Citeer web
| taal=en
| title = Scala IDE for Eclipse
| accessdate = 2012-12-15
| url = http://typesafe.com/technology/scala-ide
}}</ref>, [[IntelliJ IDEA]]<ref>{{Citeer web
| taal = en
| title = Scala
| work = JetBrains Plugin Repository
| accessdate = 2013-04-28
| url = http://plugins.jetbrains.com/plugin/?idea&pluginId=1347
}}</ref> of [[NetBeans|NetBeans IDE]]<ref>{{Citeer web
| lang= en
| title = Scala Plugins for NetBeans
| work = Scala - NetBeans Wiki
| accessdate = 2013-04-28
| url = http://wiki.netbeans.org/Scala
}}</ref>, bieden ook ondersteuning voor Scala. Alhoewel de [[byte-code]] [[Interoperabiliteit|interoperabel]] is met (bestaande) Java code, draagt Scala niet zoals Java de last van vroegere ongelukkige keuzes.<ref>Bedoeld wordt: type erasure, checked exceptions en het non-unified typesysteem</ref>

{| class="wikitable" style="font-size: 80%; float:left; margin-right:1em;"
! Tijd-as!! colspan="3" | Concept <math>\longrightarrow</math> Deployment
|-
! Technologie !! Design-time !! Compile-time !! Runtime
|-
| Conventioneel
statisch type
|| Bewerken||

Syntax-checking

<math>\swarrow</math>
|| Executie
Error checking

<math>\swarrow</math>Type checking
|-
| Scala IDE|| Bewerken<br>Syntax-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 (taalkunde)|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.

[[Schaalbaarheid|Schaalbaar]] kan uitgelegd worden in de volgende domeinen:
#Scala is geschikt voor parallelle uitvoering en is schaalbaar in productieomgevingen met een groeiend aantal [[Processor (computer)|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: [[Actor model|Actors]];
#Op de taalkern kan een taaluitbreiding gemaakt worden, bijvoorbeeld in bibliotheken (bijv. het <code>break</code> statement).
#Scala kan zowel [[Imperatief programmeren|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 [[smartphone]]s tot grote [[Multikernprocessor|multicore]]-of [[Multiprocessing|multiprocessor-platforms]];
#En dat op verschillende platforms: JVM, [[Common Language Runtime|CLR]] (CLR de mobiele apps uitgezonderd) en [[LLVM]]<ref>{{Citeer web
| lang=en
| last = Reedy| first = Geoff
| title = Scalathon 2011: Geoff Reedy
| accessdate = 2013-03-19
| date = 2011-09-08
| url = http://vimeo.com/28774096
}}</ref><ref>{{Citeer web
| lang=en
| last = Reedy| first = Geoff
| title = Compiling Scala to LLVM
| location = St. Louis, Missouri, United States
| accessdate = 2013-02-19
| date = 2012-09-24
| url = http://www.infoq.com/presentations/Scala-LLVM
}}</ref>;
#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 selftype]]s, [[abstracte type member]]s en genericiteit, [[geneste klassen]] en mixin-compositie met behulp van [[trait]]s.
<blockquote>[[James Gosling]], medebedenker van de programmeertaal Java, werd gevraagd welke JVM-taal uitgezonderd Java hij zou kiezen; "Scala", antwoordde hij prompt.<ref>{{Citeer web
| last = Bien| first = Adam| lang=en
| title = java.net@JavaONE: Which Programming Language J. Gosling would use now, except Java?
| work = Adam Bien's Weblog
| accessdate = 2012-12-15
| date = 2008-05-08
| citaat = Which Programming Language would you use now on top of JVM, except Java? The answer was surprisingly fast and very clear: - Scala.
| url = http://www.adam-bien.com/roller/abien/entry/java_net_javaone_which_programming
}}</ref></blockquote><blockquote>[[James Strachan]], die [[Groovy]] heeft gecreëerd, beschrijft Scala als mogelijke opvolger van Java<ref>{{Citeer web
| achternaam = Strachan| voornaam = James| auteurlink=James Strachan
| title = Scala as the long term replacement for java/javac?
| work = James Strachan's Blog
| accessdate = 2012-12-15
| date = 2009-06-06
| citaat = I can honestly say if someone had shown me the Programming in Scala book by Martin Odersky, Lex Spoon & Bill Venners back in 2003 I'd probably have never created Groovy.
| url = http://macstrac.blogspot.nl/2009/04/scala-as-long-term-replacement-for.html
}}</ref>: "Ik kan eerlijk zeggen dat als iemand me het "Programming in Scala"<ref>{{Citeer boek
| title = Programming in Scala: [a comprehensive step-by-step guide]| edition = 2
| last = Odersky| first = Martin| authorlink= Martin Odersky
| coauthors = Lex Spoon, Bill Venners| publisher = Artima Press
| isbn = 9780981531649
| date = 2011-01-04
}}</ref>-boek van Martin Odersky, Lex Spoon & Bill Venners in 2003 had laten zien, ik waarschijnlijk nooit Groovy zou hebben gemaakt."</blockquote>

{{Inhoud links|klein}}

== Voorbeelden==
===Hello World, commandline===
Een [[Hello world (programma)|Hello, world!]]-programma in Scala:
<syntaxhighlight lang="scala">
object HelloWorld extends App {
 println("Hello, world!")
}
</syntaxhighlight>
In tegenstelling met het [[Java (programmeertaal)#Voorbeeldprogramma|Java-voorbeeldprogramma]] is er geen klassedeclaratie nodig en niets hoeft als <code>static</code> gedeclareerd te worden<ref>{{Citeer web
| last = Subramaniam| first = Venkat | lang=en
| title = Scala for the Intrigued
| work=Dr. Venkat Subramaniam (011513) on Vimeo
| location = Atlanta
| accessdate = 2013-03-06
| date = 2013-01-15
| url = http://vimeo.com/57988159
}}</ref>, in plaats daarvan wordt er een [[Singleton (ontwerppatroon)|singleton]]-object gebruikt. Het entrypoint <code>main</code> wordt via de trait '''App''' ingebracht.

=== Hello World als een Scala-shellscript<ref>{{Citeer web
| lang=en
| title = Scala man page
| accessdate = 2013-03-08
| date = 2007-04-18
| url = http://www.scala-lang.org/docu/files/tools/scala.html
}}</ref> ===
{| class="wikitable"
! Unix|| Windows
|-
| <syntaxhighlight lang="bash">
#!/bin/sh
exec scala "$0" "$@"
!#
// Hier het Scala-script
println("Hello, world!")
// Print de eventuele argumenten
args.toList foreach println
</syntaxhighlight>
|
<syntaxhighlight lang="winbatch">
::#!
@echo off
call scala %0 %*
goto :eof
::!#
println("Hello, world!")
args.toList foreach println
</syntaxhighlight>
|}

===Hello World in een grafische gebruikersomgeving===
Een Hello, World!-[[GUI]]-programma in Scala:
[[Bestand:Scala REPL HelloWorld.PNG|thumb|Scala REPL HelloWorld als GUI]]
<syntaxhighlight lang="scala">
import swing._

object HelloWorld extends SimpleSwingApplication {
 def top = new MainFrame {
 title = "Hello, world!"
 contents = new Button {
 text = "Click Me!"
 }
 }
}
</syntaxhighlight>

===Hello World, .Net-versie===
Een Hello, World!-[[.Net]]-programma in Scala:
[[Bestand:Scala dotNet HelloWorld.PNG|thumb|Scala HelloWorld als .Net-dialoog]]
<syntaxhighlight lang="scala">
import swing._

object HelloDotNetWorld {
 def main(args: Array[String]) {
 System.Windows.Forms.MessageBox.Show("Hello, .net world!")
 }
}
</syntaxhighlight>

===Illustratie van de verschillen tussen syntaxis van Java en Scala===
{|
| <syntaxhighlight lang="java">
// Java:

int moelijkeFunctieMetDerdeMachtsEnLog(int num) {
 int numSquare = num*num;
 return (int) (Math.cbrt(numSquare) +
 Math.log(numSquare));
}
</syntaxhighlight>
| <syntaxhighlight lang="scala">
// 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
}
</syntaxhighlight>
|}
Hier zijn de volgende verschillen tussen de syntaxis zichtbaar:
*In Scala zijn [[puntkomma]]'s niet altijd vereist;
* [[Hoofdletter]] voor [[datatype]]n: <code>Int</code>, <code>Double</code>, <code>Boolean</code> in plaats van respectievelijk <code>int</code>, <code>double</code>, <code>boolean</code>.
*Datatype van een [[variabele]], [[parameter]] of [[subprogramma|functie]] staat achter de [[Identifier (programmeren)|identifier]], zoals in [[Pascal (programmeertaal)|Pascal]], in plaats van vooraan;
*Procedure of functie worden voorafgegaan met het <code>def</code> sleutelwoord;
*Een functie of [[Methode (objectoriëntatie)|methode]] heeft een [[Isgelijkteken|=]]-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 <code>val</code>- voor een onveranderlijke of <code>var</code>-sleutelwoord voor een muteerbare variabele;
*De <code>return</code>-operator is niet verplicht maar wel toegestaan; de waarde van het laatst uitgevoerde statement is de return waarde en definieert het type van de functie (type-inferentie);
*In plaats van de Java-cast-operator <code>(Type) foo</code>, gebruikt Scala <code>foo.asInstanceOf[Type]</code>, maar meestal een gespecialiseerde conversiefunctie zoals <code>toDouble</code> of <code>toInt</code>;
*In plaats van de Java's <code>import math.*;</code> gebruikt Scala <code>import math._</code>. De [[underscore]] is Scala's [[jokerteken]];
* [[Infix]]-notatie: Een functie of [[Methode (objectoriëntatie)|methode]] <code>def foo()</code> kan op de eenvoudig wijze worden aangeroepen als <code>foo</code>. Methode <code>thread.send(signo)</code> kan worden aangeroepen als <code>thread&nbsp;send&nbsp;signo</code>; en methode <code>foo.toString()</code> kan gebruikt worden met <code>foo&nbsp;toString</code>. Deze vrijheid staat gebruik als Domain-Specific Language toe.
Enkele andere basisverschillen in de syntaxis:
* [[Array]]-elementen worden geadresseerd als functie aanroepen, bijvoorbeeld <code>array(i)</code> in plaats van <code>array[i]</code>;
*Generieke typen worden aangeduid tussen [[Vierkante haak|vierkante haken]] in plaats van Java's vishaken: <code>List&lt;String&gt;</code>;
*In plaats van de pseudotype <code>void</code> heeft Scala het actuele [[Singleton (ontwerppatroon)|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.<ref>{{Citeer web | taal = en |url=http://homepages.inf.ed.ac.uk/wadler/pizza/gj/ | title=A Generic Java Language Extension | date=1999-04-14 | accessdate=2012-11-25}}</ref> (Odersky is in 2011 uitgeroepen tot Top Java Ambassador.<ref>{{Citeer web
| last = Schlosser| first = Hartmut
| taal=en
| title = JAX Innovation Awards 2011: The Winners are...
| work = jaxenter
| accessdate = 2013-04-18
| date = 2011-06-23
| url = http://jaxenter.com/jax-innovation-awards-2011-the-winners-are-36551.html
}}</ref>) 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==
Scala draait zowel op de Java- als de .NET-platformen. Het doet zijn naam eer aan als "scalalable language" om op smartphones tot cloudomgevingen te kunnen draaien. Alhoewel er een traditionele hang is naar de JVM is er geen reden toe. Vrij snel is er met beperkte middelen een succesvolle implementatie op het toen (juni 2004) jonge .NET-platform gemaakt. Het is juist een uitdaging op meer platformen te kunnen draaien. Dan krijgt het "Write once, run anywhere"-adagio een diepere betekenis, men wordt met Scala ook virtuelemachineonafhankelijk.

De middelen zijn echter beperkt en men moet hier keuzes maken. Belangrijk is hoe [[Microsoft]] - ze hebben een vergelijkbare taal [[F Sharp|F#]] - hier mee omgaat. Zullen ze deze [[opensourcesoftware]] dulden naast hun [[intellectuele eigendom]]men?

De Scala-distributie<ref>{{Citeer web| last = Scala Team| taal = en| title = Scala Distribution| work = The Scala Programming Language| accessdate = 2013-04-12| date = 2013-03-29| url = http://www.scala-lang.org/downloads#}}</ref> is, inclusief [[compiler]] en [[Bibliotheek (informatica)|Scala Standard Library]] vrijgegeven onder [[BSD-licentie|BSD]]-achtige voorwaarden met slechts drie [[clausule (bepaling)|clausules]]<ref name="licentie" />.

===Java-interoperabiliteit===
Bestaande Java-code en programmeerervaring zijn herbruikbaar. Scala-programma's draaien ook op de diverse Java VM's, en zijn byte-code ([[classfile]])-compatibel met Java, zodat er volledig gebruikgemaakt kan worden van de bestaande Java-bibliotheken of bestaande applicatie-code ([[JavaBeans]] incluis). Ook met [[Google Android]] voor het ontwikkelen van [[mobiele app]]s voor mobiele telefoons. Vanuit Scala-code kunnen de Java-klassen geïnstantieerd worden en hun respectievelijke methoden aangeroepen worden en vanuit Java kunnen de Scala-klassen en objecten vaak gebruikt worden met hun methoden. De integratie is vaak naadloos. Een goed voorbeeld hiervan is het [[String (informatica)|String]] object dat in Java altijd immutable en daardoor type-veilig is geweest. Door deze eigenschappen is het niet geherdefinieerd in de Scala-bibliotheek en wordt er onmiddellijk verwezen naar <code>java.lang.'''String'''</code>. Met Java kan echter geen Scala-gedefinieerde traits worden gebruikt omdat Java dat niet kent.

====JVM-ontwikkelomgevingen====
Een verscheidenheid aan ontwikkelingsmogelijkheden bestaan, van eenvoudig tot geavanceerd. Ze kunnen op de computer worden geïnstalleerd op voorwaarde dat er al een Java-[[JDK]] geïnstalleerd is.

=====Scala Interactieve Interpreter (REPL)=====
De [[Read–eval–print loop|REPL]] is [[command-line-interface]]-gebaseerde eenvoudige, interactieve standaardtool om bijvoorbeeld verkennend te programmeren. Het is handig om code te testen maar ook om te zien wat de resulterende types worden.<br>Wanneer de Scala Distribution van Scala-lang.com<ref>{{Citeer web| taal=en| last = Scala Team| title = Scala Distribution| work = The Scala Programming Language| accessdate = 2012-12-16| date = 2013-03-15| url = http://www.scala-lang.org/downloads/}}</ref> is geïnstalleerd, dan kan door <code>scala</code> in een command-line-interface, de REPL gestart worden. Een REPL is een eenvoudige, interactieve computerprogrammeeromgeving en hiermee is het mogelijk Scala als scripttaal te gebruiken. Het heeft met de tabtoets een completion-functie voor pakketten, klassen en methoden. In zo'n interactieve Scalasessie wordt na een [[Enter (toets)|enter]] de expressie geëvalueerd en indien compleet en valide, de resultaten getoond.

[https://web.archive.org/web/20130604100815/http://www.simplyscala.com/ Simply Scala] is een online REPL. Bedoeld voor een snelle kennismaking met Scala.

De Scala Interactieve Interpreter of Scala REPL komt ook voor in de diverse IDE's en de SBT. In de IDE heet het "Scala Interpreter" en in de SBT kan het geopend worden door het commando <code>console</code>.

=====Eclipse for Scala IDE=====
Sinds 2011 is de plug-inontwikkeling ter hand genomen als een EPFL/Typesafe-project. Daarvoor werd de ontwikkeling door een enkeling van Electricité de France Trading gedaan.

<!--Console Window, Open console button -> Scala Console = Scala console
Scala -> Create Scala interpreter in project = Scala console
Window -> Show view -> Scala Interpreter = Scala Interpreter
Button "Run Selection in Scala Interpreter" = Scala Interpreter

Als Run configuration "Scala Interpreter"
-->
Op typesafe.com kan een compleet voorgeconfigureerde "Scala IDE for Eclipse"<ref>{{Citeer web| taal=en| title = Scala IDE for Eclipse| accessdate = 2012-12-15| url = http://typesafe.com/technology/scala-ide}}</ref> gedownload worden.
<!--ONVERTAALD

======Scala interpreter in Scala Project======
======Scala Worksheet======
=====IntelliJ IDEA=====
=====NetBeans IDE=====
=====Simple Build Tool=====
Download de gewenste versie van SBT.<ref>https://web.archive.org/web/20130610112921/http://scalasbt.artifactoryonline.com/scalasbt/sbt-native-packages/org/scala-sbt/sbt/ Index of sbt-native-packages/org/scala-sbt/sbt</ref>

=====[[Framework (software)|Raamwerk]]en=====
{| class="vatop"
|
{| class="wikitable"
! Framework !! Description !! Kind
|-
| [[Akka (software)|Akka]] || Akka is an event-driven middleware framework || Middle-ware
|-
| BlueEyes || A lightweight Web 3.0 framework || Web&nbsp;Framework
|-
| Bowler || Bowler is a RESTful, multi-channel ready web framework || Web&nbsp;Framework
|-
| Circumflex || A minimalistic DSL for quick and robust Web application development. || Web&nbsp;Framework
|-
| Finagle || A fault tolerant, protocol-agnostic RPC system. || …
|-
| [[Gatling (software)|Gatling]] || Web[[stresstest]]|| Test
|-
| Lift Web || Lift is the most powerful, most secure Web Framework<br>available today. || Web&nbsp;Framework
|-
| Ostrich || A stats collector & reporter for Scala servers. || Utility
|-
| Pinky || Pinky provides out-of-the-box support for dealing<br>with forms, domain objects, jdbc and rss/xml/json/html content types || …
|-
| Play! || High-productivity web application framework || Web&nbsp;Framework
|-
| Riak Scala Client || … || …
|-
| [[Scala for IDE]] || … || Tool
|-
| ScalaCheck || … || Test
|}
|
{| class="wikitable"
! Framework !! Description !! Kind
|-
| … || … || …
|-
| Scalate || Scalate is Template Language engine for generating text. || Template engine
|-
| ScalaTest || ScalaTest also includes a domain specific language (DSL) for browser-based tests using Selenium. || Test
|-
| Scalatra || A tiny, Sinatra-like Web&nbsp;Framework. || Web&nbsp;Framework
|-
| ScalaLogging || … || …
|-
| ScalaMock || … || …
|-
| Scalariak || … || …
|-
| [[SLICK (software)|SLICK]] || Scala Language Integrated Connection Kit || Middle-ware
|-
| specs2 || … || Test
|-
| spray || … || …
|-
| Sweet || Building dynamic web content that runs on any Java servlet server || Web&nbsp;Framework
|-
| Unfiltered || A toolkit for servicing HTTP requests in Scala || Web&nbsp;Framework
|-
| … || … || …
|-
| Xitrum|| Xitrum is an async and clustered web framework and HTTP(S) server || Web&nbsp;Framework
|}
|}
-->

===.NET-integratie===
Scala is primair ontwikkeld voor de Java Virtual Machine, inmiddels zijn er ook implementaties voor .NET<ref>{{Citeer web
| lang = en| last = Garcia| first = Miguel
| title = Scala comes to .Net
| accessdate = 2013-02-21
| date = 2011-07-22
| url = http://www.scala-lang.org/node/10299/
}}</ref><ref>{{Citeer web
| lang =en
| last = Garcia| first = Miguel
| title = Downloads scaladotnet
| work = Github Repository
| accessdate = 2012-12-15
| date = 2012-03-10
| url = https://github.com/magarciaEPFL/scaladotnet/downloads
}}</ref><ref>{{Citeer web
| lang=en
| last = Garcia| first = Miguel
| title = The Scala Compiler Corner, for .NET and Mono fans
| accessdate = 2013-03-04
| url = http://lampwww.epfl.ch/~magarcia/ScalaNET/
}}</ref><ref>{{Citeer web
| lang=en
| last = Gilham| first = Steve
| title = Hello Scala.net
| work = Distributed Memory
| accessdate = 2013-03-23
| date = 2012-08-15
| url = http://stevegilham.blogspot.nl/2012/08/hello-scalanet.html
}}</ref>.

==Kenmerkende taalconcepten==
Scala is objectgeoriënteerd, in de zin dat elk waarde een object is. De taal is ook een functionele programmeertaal, in de zin dat iedere functie ook een waarde is. Scala is statisch en sterk getypeerd, net als de programmeertaal Java. Enkele andere talen die ook op de JVM-infrastructuur werken, zoals [[Clojure]], [[Ruby (programmeertaal)|Ruby]] en Groovy, maar ook [[Python (programmeertaal)|Python]], [[JavaScript]] en [[Smalltalk (programmeertaal)|Smalltalk]] zijn daarentegen dynamisch getypeerd. Sinds Scala versie 2.10 is er voor de onoverkomelijke gevallen ook een [[Typesysteem#Dynamische typering|dynamisch type]] beschikbaar.

===Lichtgewicht syntaxis en [[uitdrukkingskracht]]===
Er is een onderzoek gedaan naar de zeggingskracht van talen,<ref>{{Citeer web| last = Berkholz| first = Donnie| title = Programming languages ranked by expressiveness| work = Donnie Berkholz's Story of Data| accessdate = 2014-03-23| url = http://redmonk.com/dberkholz/2013/03/25/programming-languages-ranked-by-expressiveness/}}</ref> Scala was in de top als 18<sup>e</sup> gekwalificeerd. Hieronder een oplossing van een probleem in Java (43<sup>e</sup>).
<syntaxhighlight lang="java">import java.util.Iterator;
import java.util.Map;

public class gistfile1 {
 public static String convertPathArgsHashToString(Map pathArgs) {
 StringBuffer pathArgsString = new StringBuffer();
 String argumentValue;
 boolean firstRun = true;
 if (pathArgs != null) {
 for (Iterator argumentIterator = pathArgs.keySet().iterator();
 argumentIterator.hasNext();) {
 String argument = (String) argumentIterator.next();
 if (firstRun) {
 firstRun = false;
 pathArgsString.append("?");
 } else {
 pathArgsString.append("&");
 }

 argumentValue = (String) pathArgs.get(argument);
 pathArgsString.append(argument);
 if (argumentValue != null) {
 pathArgsString.append("=");
 pathArgsString.append(argumentValue);
 }
 }
 }

 return pathArgsString.toString();
 }

 /**
 * @param args
 */
 public static void main(String[] args) {
 // TODO Auto-generated method stub

 }

}</syntaxhighlight>
En hetzelfde probleem opgelost in Scala:
<syntaxhighlight lang="scala">object gistfile1a extends App {
 def convertPathArgsHashToString(pathArgs: Map[String, String]) = {
 (if (pathArgs.isEmpty) "" else "?") +
 pathArgs.map(kv => kv._1 + "=" + kv._2).mkString("&")
 }
 println(convertPathArgsHashToString(Map()))
}</syntaxhighlight>

====Puntkomma-inferentie====
De puntkomma om het einde van een statement aan te geven, is in Scala vaak overbodig. Met meerdere statements op een regel kan het van belang zijn, maar dit is een ongewenste lay-out. De precieze regels voor de statementscheiding zijn eenvoudig.

Een regeleinde wordt geïnterpreteerd als een puntkomma als niet aan een van de volgende voorwaarden wordt voldaan:
* De onderhavige lijn eindigt met een woord wat niet geldig kan zijn als het einde van een statement, zoals een punt of een infix-operator.
* De volgende regel begint met een woord dat geen begin van een statement kan zijn.
* In het geval van een statement met haakjes (…) of […] de regel ertussen eindigt.
Een programmeur hoeft dit niet te weten, in de IDE is er een knopje voor het tonen van de inferentie-puntkomma's.

Voor het afbreken van een lang statement het is handig een operator op de vorige regel te laten staan.

====Type-inferentie====
{{Zie hoofdartikel|Type-inferentie}}
Type-inferentie of impliciete typering is de mogelijkheid van een programmeertaal als Scala om automatisch het type van een expressie te deduceren.

====Notatie infix-operator====
Met Scala bestaat de mogelijkheid de starre <code>objectinstantienaam.methode(par1, ...)</code>-notatie te verlaten en een relaxte [[Prefix- en suffixnotatie|infixnotatie]] te gebruiken. De infixnotatie wil zeggen dat de methode een operator wordt omdat hij tussen de operanden komt te staan.
<syntaxhighlight lang="java">
x foo /*is infixnotatie voor*/ x.foo();
x foo y /*is infixnotatie voor*/ x.foo(y);
y :: x /*is infixnotatie voor*/ x.::(y); // dubbelepunt verwisselt de operanden onderling
s indexOf ('o', 5) /*is infixnotatie voor*/ s.indexOf('o', 5)
// maar ook
7 + 2 /*is infixnotatie voor*/ 7.+(2) // Waarbij + een methode is
</syntaxhighlight>
Zodoende zijn de gebruikelijke operators (+, -, *, /, etc.) in de standaardbibliotheek gedefinieerd in plaats van hard gecodeerd in de compiler waardoor zowel de taal als de compiler lichter worden.
Naast dat de <code>objectinstantienaam.methode(par1, ...)</code> notatie nog steeds gebruikt kan worden, heeft de infixnotatie de volgende voordelen:
* De broncode wordt duidelijker omdat de "ruis" van punten en haakjes verdwijnt.
* Het is opeens mogelijk zelf operators te (her)definiëren.
* Met programmacode gedefinieerde operators is het mogelijk een nieuwe (DSL-)taal te maken.
* De operators zijn geen taalelement meer maar verhuizen naar de standaardbibliotheek. Dit maakt de compiler lichter.

====For-iteraties (For-comprehension)====
Het [[Repetitie (informatica)#For en Foreach|for-loop]]-statement is een essentiële softwareconstructie. In de toepassing is de efficiëntie belangrijk omdat de verwerkingstijd door de veelvuldige repetitie worden uitvergroot. Scala voorziet in de zogenaamde for-comprehension waarbij for-loops worden omgeschreven naar een functionele versie. Behalve een vrij efficiënte constructie met hogere-ordefuncties met staartrecursie, kan er nog een snelheidswinst ontstaan door parallelle verwerking.

''For-comprehension'' (een variant van [[lijstcomprehensie]]) is een belangrijke bewerking door de compiler om als for-loops geschreven statements om te vormen tot een constructie waarbij uiteindelijk een nieuwe collectie wordt gegenereerd, gedreven door een collectie. De for-loop wordt dus omgevormd naar een gegenereerde lijst (lijstgenerator), eventueel een filterfunctie en een collectie-naar-collectie-functie:

{| class="vatop"
|-
| <syntaxhighlight lang="scala">
// Scala origineel:
for {
 i <- 1 until n
 j <- 1 until i // ^
 if isPrime(i + j) // | Blok A
} yield (i, j) // |
</syntaxhighlight>
| <syntaxhighlight lang="scala">

// Door de compiler omgevormd 1e slag:
//
//
(1 until n) flatMap (i =>
 for (j <- (1 until i) if isPrime(i + j)) yield (i, j))
// <--------- Blok A --------->
</syntaxhighlight>
| <syntaxhighlight lang="scala">

// Door de compiler omgevormd 2e slag:
//
 (1 until n) flatMap (i =>
 (1 until i).withFilter(j =>
 isPrime(i + j))
 .map(j => (i, j)))
</syntaxhighlight>
|}
In werkelijkheid drukt de Scala-compiler de for-expressies uit in termen van map, flatMap en een [[Luie evaluatie|luie variant]] van een filterfunctie. Door deze versie met hogere-ordefuncties kan de klassieke teller variabele(n) - die een neveneffect zou geven - verdwijnen en is het daarom mogelijk om diverse optimalisaties te gebruiken, bijvoorbeeld parallelle verwerking. Voor de programmeurs is het vaak een voordeel dat zij de gewenste verwerking nog steeds een for-loop kunnen uitdrukken; het ziet er begrijpelijker uit door de analogie met de wiskundige notatie, zoiets als ∀&nbsp;''n''&nbsp;∈&nbsp;ℕ: ''n''<sup>2</sup>&nbsp;is even. Ook kan gesteld worden dat dit een ([[SQL]]-)query-achtige presentatie is.
Kort samengevat biedt het for-taalelement een alternatieve en praktischer manier om iets te schrijven met behulp van een bekende notatie. Dit wordt [[syntactische suiker]] genoemd.

=== Robuustheid===
====Het uniforme type-systeem====
[[Bestand:Scala Unified Types Hierachy.jpg|thumb|links|Scala Unified Types Hierachy]]
In een non-unified typesysteem-taal zoals bijvoorbeeld Java wordt duidelijk onderscheid gemaakt tussen primitieve types (zoals <code>int</code>, <code>char</code> en <code>boolean</code>) en referentietypes (elke klasse). Alleen referentietypes kunnen deel uitmaken van een hiërarchische klassenstructuur. In Scala, echter, waar alles een object is, erven alle typen van een top-levelklasse ''Any'', wiens onmiddellijke kinderen ''AnyVal'' (waardetypes, zoals <code>Byte</code>, <code>Short</code>, <code>Int</code>, <code>Long</code>, <code>Double</code>, <code>Float</code> en <code>Unit</code>, <code>Boolean</code>, <code>Char</code>) en ''AnyRef'' (referentietypes, bijvoorbeeld: ''String'', dit is alias <code>java.lang.'''String'''</code> en alle andere (Java)klassen) zijn. Dit betekent dat het Java's onderscheid tussen primitieve types en boxed types (bijvoorbeeld <code>int</code> versus <code>Integer</code>) in Scala niet aanwezig zijn, [[Boxing (informatie)|boxing]] en unboxing is volledig transparant voor de gebruiker en door de compiler wordt er geoptimaliseerd naar JVM-primitieven.

''Unit'' is Scala's <code>void</code>, het is een singleton-type, dus met slechts een geïnstantieerd object. Met Scala 2.10 zal het mogelijk zijn nieuwe waardetypes te definiëren. (Dit was voorheen niet mogelijk omdat het <code>sealed</code> [[sleutelwoord]] in de runtime-library gebruikt is.) Uiteindelijk is ''Nothing'' subtype van alle klassen echter zonder overerving. ''Nothing'' is altijd het resultaat van een [[Exception handling|exception]].

====Option-object====
Wanneer in Scala bekend is dat de methode soms geen waarde zal retourneren, kan gebruikgemaakt worden van object ''Option'', die de [[Klasse (informatica)|klasse]] ''Some'' of object ''None'' kan teruggeven. (Objecten zijn eenmalige instanties van een klas.) Bijvoorbeeld:

<syntaxhighlight lang="scala">def computeFoo: Optie [Foo] = {...}</syntaxhighlight>
Let op de "Option van Foo"-returntype.
<syntaxhighlight lang="scala">computeFoo wedstrijd {
 case Some(foo) => ... // heeft een Foo, doe er iets mee
 case None => ... // kreeg geen Foo, deal with it
}</syntaxhighlight>

Hiermee wordt de ongelukkige keuze<ref>{{Citeer web | achternaam = Hoare| voornaam = Tony|auteurlink=Tony Hoare |taal=en| url=http://www.infoq.com/presentations/Null-References-The-Billion-Dollar-Mistake-Tony-Hoare | title=Null References: The Billion Dollar Mistake. | date=2009-08-25 | accessdate=2012-11-29}}</ref> met null-waarden en ook [[defensief programmeren]] vermeden. Overigens zijn alle Scalaklassen subklassen van ''Any'' en is ''Nothing'' een subtype van alle Scalaklassen. De null-waarde is nog noodzakelijk voor de Java- en .NET-integratie. Het is van type <code>scala.'''Null'''</code> en daardoor verenigbaar met elke refentietype.

===Objectoriëntatie===
Scala is een zuiver objectgeoriënteerde taal in de zin dat elke waarde een object is. Gegevenstypen en gedrag van objecten worden beschreven door klassen en traits. Klassen kunnen worden uitgebreid met klas-abstracties en door een flexibele en probleemloze mixin-gebaseerde compositiemechanisme met meervoudige overerving.

====Klassen en objecten====
Scala heeft geen statische (aangeduid met <code>static</code>) variabelen of methoden. In plaats daarvan heeft het singleton-objecten, wat in essentie klassen zijn met slechts een eenmalige instantie. Singletons zijn gedeclareerd met <code>object</code> in plaats van <code>class</code>. Het is algemeen gebruik een class met dezelfde naam te maken en de methoden en statische variabelen in het zogenaamde companion-object te zetten. Een class heeft toegangsrechten over alle variabelen en methoden van het companion-object ook al zijn deze private en andersom.

===Dependency Injection===
====Meervoudige overerving met Traits====
Traits zijn Scala's vervanger voor [[Interface (Java)|Java-interfaces]]. Interfaces in Java zijn zeer beperkt, daarin kunnen enkel abstracte functies gedeclareerd worden. Ook moeten dezelfde methoden opnieuw worden geïmplementeerd bij toepassing. Traits zijn vergelijkbaar met [[mixin]]-klassen in die zin dat ze bijna alle mogelijkheden hebben van gewone concrete klassen, echter zonder klasse parameters (Scala's equivalent met Java-constructorparameters), omdat traits nu eenmaal altijd worden verbonden met een concrete klas. De <code>super</code>-operator gedraagt zich bijzonder in traits, waardoor traits kunnen worden verbonden met behulp van compositie in aanvulling op overerving.

{| class="wikitable" style="text-align:center;" align="right"
|-
! SpaceShip!!Bewapend!!Pantsering!!Medic
|-
|style="text-align:left;"|Slagschip||{{Check}}|| {{Check}}||{{Check}}
|-
|style="text-align:left;"|Commandoschip||{{Check}}|| {{Check}} ||
|-
|style="text-align:left;"|Gevechtsschip||{{Check}}||||
|-
|style="text-align:left;"|Ondersteuningsschip||||{{Check}}||{{Check}}
|}
<syntaxhighlight lang="scala">object StarWars {

 class Ship(var health: Int = 0) {
 def hit = health -= 2
 def repaired(howGood: Int) { health += howGood }
 }

 trait Gun {
 def fireAt(s: Ship) = s.hit
 }

 trait Medic {
 }

 trait Shield {
 self: Ship =>
 override def hit = self.health -= 1
 }

 trait Repair {
 def repairTool(s: Ship, quality: Int) = s.repaired(quality)
 }

 val imperialFighter = new Ship(10) with Gun
 val imperialRepairShip = new Ship(10) with Repair with Medic

 val rebelFighter = new Ship(10) with Gun

 imperialFighter.fireAt(rebelFighter)
 println(rebelFighter.health)
}</syntaxhighlight>

Vaak wordt door <code>trait</code>s eenvoudig krachtige (generieke) methoden overgeërfd. Een voorbeeld hiervan is de methode <code>scala.collection.Traversable.mkString</code> voor snelle geformatteerde output. Deze werkt namelijk op een hele reeks van structuren uit de Collections-bibliotheek.
<!--====Anonieme functies====
====Immutualiteit====
====Lazy (niet stricte) evaluatie====
====Staartrecursie====
====Caseklassen en patroonvergelijking====
====Partiële functies====
====Expressieve type systeem====
====Type verrijking====
==Concurrency== -->

===Functioneel programmeren===
In het functioneel programmeren worden de programma's uitgevoerd door het evalueren van expressies, in tegenstelling tot imperatief programmeren, waar programma's worden samengesteld uit statements die globale toestand veranderen wanneer het uitgevoerd wordt. Functioneel programmeren vermijdt het gebruik van muteerbare variabelen en destructieve re-assigments ook bekend als [[neveneffect]]en. Scala voorziet in totale ondersteuning van [[functioneel programmeren]] door de faciliteiten [[currying]], [[pattern matching]], [[algebraic data types]], [[lazy evaluation]], [[tail recursion]], [[immutable object|immutability]] etc. In Scala zijn functies "eerste klas", dit wil zeggen: iedere functie is een waarde. Hierdoor kunnen ze hetzelfde gebruikt worden als waarden: als argumenten voor andere functies of worden geretourneerd als resultaat van een functie. Deze uitwisselbaarheid staat bekend als [[referentieel transparant]]ie en vereist tevens dat de functies geen neveneffecten hebben. Het gebruik van functies als argument is beter bekend als hogere-ordefuncties en het retourneren van functies maakt onder andere functie-[[currying]] mogelijk. Scala heeft een eenvoudige syntaxis voor het definiëren van [[anonymous function]]s, het ondersteunt hogere-ordefuncties en currying en het staat geneste functies toe. Het ondersteunt patroonherkenning oftewel patroonvergelijking. Patroonvergelijking kan gebruikt worden in XML-verwerking, dat ook in Scala ondersteund wordt.

====Functies====
Alles is een expressie. In tegenstelling tot [[C (programmeertaal)|C]] of Java, maar vergelijkbaar met talen zoals [[Lisp (programmeertaal)|Lisp]], maakt Scala geen onderscheid tussen statements en expressies. Alle statements zijn in feite expressies die tot een waarde evalueren. Functies die zouden kunnen worden gedeclareerd als <code>void</code> in C of Java en expressies die geen waarde teruggeven (bijvoorbeeld een toekenning <code>val waarde = 42</code>) resulteren in Scala tot het type ''Unit''. Functies en operators die logischerwijs niets terug zouden kunnen geven (bijvoorbeeld de <code>throw</code>-operator of een functie die door een exception niet-lokaal opgevangen wordt) krijgen het alsnog het return type ''Nothing'', een speciaal type dat geen subobjecten heeft en het absolute bodemtype is, dat wil zeggen een subklasse van alle mogelijke typen. Zodoende is ''Nothing'' compatibel met elk type. Hierdoor kan het type-inferentie-mechanisme volledig blijven functioneren.

Ook een <code>if-then-else</code>-statement is eigenlijk een expressie met een waarde als resultaat, dat wil zeggen het resultaat van de evaluatie van een van de twee takken:
{|
|-
| <syntaxhighlight lang="scala">
// Java:
int hexDigit = x > 10 ? x + 'A' : x + '0';
</syntaxhighlight>
| <syntaxhighlight lang="scala">
// Scala:
val hexDigit = if (x > 10) x + 'A' else x + '0'
</syntaxhighlight>
|}
Dit betekent dat een dergelijk blok code overal kan worden ingevoegd waar een expressie gewenst is. Vanwege dezelfde redenen zijn <code>return</code>-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:
<syntaxhighlight lang="scala">
def printValue(x: String) {
 println("I ate a %s".format(x))
}
</syntaxhighlight>
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:
<syntaxhighlight lang="scala">
def printValue(x: String): Unit = {
 println("I ate a %s".format(x))
}
</syntaxhighlight>

====Patroonvergelijking====
Een implementatie van het [[Quicksort]]-algoritme (illustratief omdat sortering ook in de Scala Standard Library-API kan worden aangeroepen):
<syntaxhighlight lang="scala">
// Sjabloon voor generieke sortering mits het sorteerbaar "[A <% Ordered[A]]" is
def quickSort[A <% Ordered[A]](xs: List[A]): List[A] = xs match {
 case Nil => xs // lege lijst, geef lege lijst terug
 case pivot :: lijst_zonder_kop => // ontbonden lijst met de fragmenten kop en staart
 lijst_zonder_kop partition (_ < pivot) // splits de lijst in twee lijsten
 match { case (onder, boven) => quickSort(onder) ++ (pivot :: quickSort(boven)) }
}
</syntaxhighlight>

=== Parallel programmeren ===
====Collections====
[[Bestand:ScalaCollectionTraits.png|thumb|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.<ref>{{Citeer web| taal=en| achternaam = Odersky| voornaam = Martin| uteurlink=Martin Odersky| coauthors = Lex Spoon| title = Collections - Introduction| work = Scala Documentation| accessdate = 2013-03-14| url = http://docs.scala-lang.org/overviews/collections/introduction.html
}}</ref> 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 <code>scala.collection.mutable</code> en <code>scala.collection.immutable</code>. Bij ontstentenis van deze aanduiding wordt vaak de immutable versie gebruikt. Er zijn ook collecties van het pakket <code>scala.collection</code>, maar die kunnen sommige operaties overgeërfd hebben van <code>scala.collection.mutable</code>, hetgeen een neveneffect kan veroorzaken. De <code>scala.collection.immutable</code>-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"<ref>{{Citeer web| taal = en| achternaam = Odersky| voornaam = Martin| auteurlink=Martin Odersky| title = Pimp my Library
| accessdate = 2013-05-14| date = 2006-10-06| url = http://www.artima.com/weblogs/viewpost.jsp?thread=179766}}</ref>, maakt het mogelijk nieuwe methoden te gebruiken alsof ze werden toegevoegd aan bestaande typen. Dit is conceptueel vergelijkbaar met het [[C Sharp|C#]]-begrip [[extension method]]s 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 <code>implicit</code>. 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 <code>implicit</code> 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:
<syntaxhighlight lang="scala">object MeasurementUnit {
 val miFactor = .254
 trait Distance

 implicit def inch2meter(x: Inch) = new Meter(x.value * miFactor)
 implicit def meter2inch(x: Meter) = new Inch(x.value / miFactor)

 case class Meter(val value: Double) extends Distance {
 // Presentatie als een String met eenheidsymbool
 override def toString = value.toString + 'm'
 // Hiermee kunnen de lengtes opgeteld worden
 def +(m: Meter) = new Meter(value + m.value)
 }

 case class Inch(val value: Double) extends Distance {
 // Presentatie als een String
 override def toString = value.toString + '"'
 def +(m: Inch) = new Inch(value + m.value)
 }

 def main(args: Array[String]): Unit = {
 // Engelse duim gegeven, meter gevraagd
 val meter: Meter = Inch(1) // Aut. conversie met inch2meter
 // Meter gegeven, Engelse duim gevraagd
 val inch: Inch = Meter(1) // Aut. conversie met meter2inch
 val totaal: Meter = inch + meter
 println(Inch(1) + " = " + meter)
 println(Meter(1) + " = " + inch)
 }
}</syntaxhighlight>

==Testen==
Er zijn verschillende mogelijkheden om in Scala te testen:
* [http://www.scalatest.org/ ScalaTest] ondersteunt meerdere teststijlen en kan geïntegreerd worden met Java-gebaseerde frameworks (bijv. JUnit4).
* [https://github.com/rickynils/scalacheck ScalaCheck], een bibliotheek gelijk aan Haskell's [[QuickCheck]]
* [http://specs2.org/ specs2], een bibliotheek voor executable-softwarespecificaties.
* [http://scalamock.org/ 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. [[Promovendus|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,<ref>{{Citeer web| last = Bagwell| first = Phil| title = Scala Team Wins ERC Grant| work = The Scala Programming Language| accessdate = 2013-03-22| date = 2011-01-10| url = http://www.scala-lang.org/node/8579}}</ref><ref>{{Citeer web| last = Clark| first = Jack| title = Scala gets grant to tackle parallel challenge| work = ZDNet| accessdate = 2013-03-22| date = 2011-01-17| url = http://www.zdnet.com/scala-gets-grant-to-tackle-parallel-challenge-4010021509/}}</ref> 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.<ref>{{Citeer web| last = Bagwell| first = Phil| title = Scala Solutions Founded| work = The Scala Programming Language| accessdate = 2013-03-22| date = 2010-10-04| url = http://www.scala-lang.org/node/7812}}</ref> Dit bedrijf is opgericht door Martin Odersky, voor zijn Scalabelang, samen met de Zweed Jonas Bonér, bedenker van de middleware [[Akka (middleware)|Akka]] voor [[distributed computing]].<ref>{{Citeer web| taal = en| achternaam = Odersky| voornaam = Martin| auteurlink=Martin Odersky| title = Introducing Typesafe| work = The Typesafe Blog| accessdate = 2013-03-22| date = 2011-05-12| url = http://typesafe.com/blog/introducing-typesafe}}</ref> 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?||2013|05|19}}
* 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]])) $&nbsp;3 miljoen in het bedrijf.
* In 2012 maakte Typesafe een financiering rond van $&nbsp;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 Typesafe 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,<ref>{{Citeer web| last = Darrow| first = Barb| title = Typesafe brings SpringSource co-founder Rod Johnson aboard| work = GigaOM| accessdate = 2013-03-22| date = 2012-09-30| url = http://gigaom.com/2012/09/30/typesafe-home-of-scala-brings-springsource-co-founder-rod-johnson-aboard/}}</ref> auteur van Expert One-on-one J2EE Development<ref>{{Citeer boek| publisher = Wiley ; Chichester : John Wiley [distributor], cop. 2003.| isbn = 9780764543852 | achternaam = Johnson| voornaam = Rod| auteurlink=Rod Johnson| title = Expert one-on-one J2EE design and development| location = Indianapolis, IN| date = 2003}}</ref>, die het [[Spring Framework]] heeft geëntameerd.

===Populariteit van Scala===
====Indeed====
Volgens [[Indeed]] Job Trends, neemt voor Scala de arbeidsvraag snel toe sinds 2010.<ref>[https://web.archive.org/web/20150207015245/http://www.indeed.com/jobtrends?q=c%23%2C+c%2B%2B%2C+clojure%2C+java%2C+javascript%2C+php%2C+python%2C+ruby%2C+scala&l=&relative=1 Indeed.com]</ref>

====RedMonk Programming Language classificering====
In de RedMonk Programming Language-classificering - die gebruikmaakt van populariteit in [[Stack Overflow]] en [[GitHub]] - blijft Scala duidelijk achter op een eersterangsgroep van 11 talen (waaronder [[Java (programmeertaal)|Java]], [[C (programmeertaal)|C]], Python, [[PHP]] en [[Ruby (programmeertaal)|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.<ref>{{Citeer web
| last = ThoughtWorks' Technology Advisory Board
| title = Technology Radar October 2012
| work = Articles and whitepapers
| accessdate = 2013-02-10
| url = http://www.thoughtworks.com/articles/technology-radar-october-2012
}}</ref> Dit betekent dat Scala als een betrouwbaar volwassen taal beschouwd mag worden en heden ten dage gebruikt kan worden.

====TIOBE-index====
[[Bestand:TIOBE Scala Ranking.png|links|thumb|Rangvolgorde sinds 2006.]]
In april 2013 zette de programmeertaalpopulariteitsindex [[TIOBE-index|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 (programmeertaal)|Scheme]] (27e) en voorbij [[Erlang (programmeertaal)|Erlang]] (31e), [[Prolog]] (30e) en [[Haskell (programmeertaal)|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 (programmeertaal)|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.

{| class="wikitable"
! Website in productie !! Back-end
|-
| style="vertical-align:top" |
* {{AU-VLAG}}[[Atlassian]]<ref>{{Citeer web| people = Kodumal, John (Cast-member), MarakanaTechTV (Coauteur)| title = Scala Typeclassopedia with John Kodumal| taal = en| accessdate = 2013-03-06| date = 2012-05-24| time = 2478 seconds| url = http://www.youtube.com/watch?v=IMGCDph1fNY}}</ref>
* {{US-VLAG}}[[eBay|eBay Inc.]]<ref>{{Citeer web| taal = en| title = eBay Classifieds Group| accessdate = 2013-03-29| url = http://www.ebayclassifiedsgroup.com/}}</ref>
* {{NL-VLAG}}[[Febo (snackbar)|Febo Beheer bv]]<ref>{{Citeer web|taal=en| last = Robinett| first = Peter| title = iFebo| work = Bubble Foundry| accessdate = 2013-04-21| date = 2012-04-25| url = http://www.bubblefoundry.com/blog/tag/ifebo/}}</ref>
* {{US-VLAG}}[[Foursquare]]<ref name="Foursquare1">{{Citeer web| taal = en| last = Merrill| first = Steven| title = Scala, Lift, and the Future| accessdate = 2012-12-15| date = 2009-11-26| url = http://grenadesandwich.com/blog/steven/2009/11/27/scala-lift-and-future/}}</ref>
* {{US-VLAG}}Gilt Groupe<ref>{{Citeer web|taal=en| last = Wunsch| first = Mark| title = Up & Running with Play 2| work = Gilt Technologie| accessdate = 2013-04-21| url = http://tech.gilt.com/
}}</ref>
* {{US-VLAG}}[[GridGain]]<ref name="GridGain">{{Citeer web| taal = en| last = Ivanov| first = Nikita| title = GridGain - Cloud Development Platform| work = GridGain - In-Memory Big Data| accessdate = 2012-12-15| url = http://gridgaintech.wordpress.com/}}</ref>
* {{US-VLAG}}[https://heluna.com/][[Heluna]]<ref>{{Citeer web|taal=en| title = Heluna tackles e-mail spam with Play Framework, Akka and Scala - The Typesafe Blog| accessdate = 2013-04-21| url = http://typesafe.com/blog/heluna-tackles-e-mail-spam-with-play-framewor}}</ref>
* {{US-VLAG}}[[Klout]]<ref>{{Citeer web| taal = en| last = Ross| first = David| title = Scaling the Klout API with Scala, Akka, and Play| work = The Official Klout Blog| accessdate = 2013-03-23| date = 2012-10-02| url = http://corp.klout.com/blog/2012/10/scaling-the-klout-api-with-scala-akka-and-play/}}</ref>
* {{US-VLAG}}[[L-3 Communications]]
* {{US-VLAG}}[[LinkedIn]]<ref name="LinkedIn1">{{Citeer web|taal=en| publisher = Infoq.com| last = Synodinos| first = Dio| title = LinkedIn Signal: A Case Study for Scala, JRuby and Voldemort| accessdate = 2012-12-15 | date = 2010-10-11| url = http://www.infoq.com/articles/linkedin-scala-jruby-voldemort}}</ref><ref name="LinkedIn2">{{Citeer web|taal=en| last = Conrad| first = Chris| title = Scala at LinkedIn: Distributed Computing with Norbert| accessdate = 2013-03-14| date = 2011-06-03| url = http://days2010.scala-lang.org/node/138/159}}</ref><ref name="LinkedIn3">{{Citeer web|taal=en| last = Scala Team| title = Scala in the Enterprise| work = The Scala Programming Language| accessdate = 2013-03-05| date = 2012-01-19| url = http://www.scala-lang.org/node/1658/#LinkedIn}}</ref><ref name="LinkedIn4">{{Citeer web|taal=en| people = Dhananjay Ragade (Cast-member), Marc Pascual (Cast-member), Joshua Erlich (Cast-member), Rui Wang (Cast-member), Joel Koshy (Cast-member)| title = Scala Usage at LinkedIn| work = LinkedInTechTalks| accessdate = 2013-01-30| date = 2012-05-14| time = 4241 seconds| url = http://www.youtube.com/watch?v=XeiiEguxRNs&feature=youtube_gdata_player}}</ref><ref name="LinkedIn5">{{Citeer web|taal=en| last = Brikman| first = Yevgeniy| work = LinkedIn Engineering| title = The Play Framework at LinkedIn| accessdate = 2013-03-05| date = 2013-02-25| url = http://engineering.linkedin.com/play/play-framework-linkedin}}</ref>
* {{US-VLAG}}Lucid Software<ref>{{Citeer web|taal=en| title = Lucid Software uses Typesafe for next generation platform| url=http://typesafe.com/public/case-studies/Lucid%20Software%20Case%20Study%20v1.0.pdf}}</ref>
* {{GB-VLAG}}Mind Candy<ref>{{Citeer web|taal=en| last = Parsons| first = Sean| coauthors = Mark Baker| title = Scala at Mind Candy| work = The Mosh Pit| accessdate = 2013-03-22| url = http://tech.mindcandy.com/2012/02/scala-at-mind-candy/}}</ref>
* {{US-VLAG}}[[Meetup.com]]<ref name="Meetup1">{{Citeer web|taal=en| title = Real-life Meetups Deserve Real-time APIs| accessdate = 2012-12-15| date = 2011-01-25| url = http://making.meetup.com/post/2929945070/real-life-meetups-deserve-real-time-apis}}</ref><ref name="Meetup2">{{Citeer web|taal=en| last = Hamblen| first = Nathan| title = Measuring Scala 2.10| accessdate = 2013-03-19| date = 2013-02-23| url = http://making.meetup.com/post/43845376134/measuring-scala-2-10}}</ref>
* {{US-VLAG}}Middlebury Interactive Languages
* {{US-VLAG}}[[Netflix]]<ref>{{Citeer web
| taal = en
| people = Jason Swartz (Coauteur)
| title = Dianne Marsh presenting "Dr Scalalove" at ScalaBay Netflix
| accessdate = 2014-05-27
| date = 2013-09-10
| time = 2301 seconds
| url = http://www.youtube.com/watch?v=h4oMUyjL3mQ&feature=youtube_gdata_player
}}</ref>
* {{US-VLAG}}[[Novell]]<ref>{{Citeer web|taal=en| title = Novell Vibe| work = Vibe.novell.| accessdate = 2013-01-28| url = https://vibe.novell.com/ssf/a/do?p_name=ss_forum&p_action=1&binderId=24895&action=view_permalink&entityType=folder&vibeonprem_url=1?vibeonprem_root=1}}</ref>
* {{NL-VLAG}}Plot Projects<ref>{{Citeer web|taal=en| title = Local marketing met push notifications| work = Plot| url = http://www.plotprojects.com/}}</ref><ref>{{Citeer web|taal=en| last = Plotproject Team| title = Developer Blog| work = Plot| accessdate = 2013-03-29| url = http://www.plotprojects.com/developer-blog/}}</ref>
* {{US-VLAG}}[[Remember the Milk|Remember The Milk]]<ref name="rememberthemilk">{{Citeer web|taal=en| last = Kilani| first = Omar| title = Real time updating comes to the Remember The Milk web app| accessdate = 2012-12-15| date = 2011-08-02| url = http://blog.rememberthemilk.com/2011/08/real-time-updating-comes-to-the-remember-the-milk-web-app/}}</ref>
* {{GB-VLAG}}[[The Guardian (Britse krant)|The Guardian]]<ref name="Guardian1">{{Citeer web|taal=en| last = Walker-Morgan| first = D.J.| title = Guardian switching from Java to Scala - The H Open: News and Features | accessdate = 2012-12-15| date = 2011-04-05| url = http://www.h-online.com/open/news/item/Guardian-switching-from-Java-to-Scala-1221832.html}}</ref><ref name="Guardian2">{{Citeer web|taal=en| last = Humble| first = Charles| title = Guardian.co.uk Switching from Java to Scala| accessdate = 2012-12-15| date = 2011-04-04| url = http://www.infoq.com/articles/guardian_scala}}</ref>
* {{US-VLAG}}[[Twitter]]<ref name="Twitter1">{{Citeer web|taal=en| last = Greene| first = Kate| title = The Secret Behind Twitter's Growth, How a new Web programming language is helping the company handle its increasing popularity.| work = Technology Review| publisher = MIT| date = 2009-04-01| accessdate = 2012-12-15| url = http://www.technologyreview.com/view/412834/the-secret-behind-twitters-growth/}}</ref><ref name="Twitter2">{{Citeer web|taal=en| last = Humble| first = Charles| title = Twitter's Shift from Ruby to Java Helps it Survive US Election| accessdate = 2012-12-26| date = 2012-11-09| url = http://www.infoq.com/news/2012/11/twitter-ruby-to-java}}</ref>
* {{US-VLAG}}Wattzon.com<ref>{{Citeer web|taal=en| last = Krikorian| first = Raffi| title = Scala + WattzOn, sitting in a tree....| accessdate = 2013-04-04| date = 2009-03-11| url = http://www.slideshare.net/raffikrikorian/scala-wattzon-sitting-in-a-tree}}</ref>
* {{NL-VLAG}}[[Computer Sciences Corporation|CSC]]<ref>{{Citeer web| taal = nl| last = Sanders| first = Rik| title = CSC en Capgemini bouwen grenscontrolesysteem| work = Computable| accessdate = 2013-03-19| date = 2011-12-05| url = http://www.computable.nl/artikel/nieuws/overheid/4302651/1277202/csc-en-capgemini-bouwen-grenscontrolesysteem.html}}</ref>
* {{US-VLAG}}[[IBM]]<ref name="IBM1">{{Citeer web| taal = en| last = Ford| first = Neal| title = Java.next: The Java.next languages| work = IBM developerWorks| accessdate = 2013-03-21| date = 2013-01-29| url = http://www.ibm.com/developerworks/java/library/j-jn1/index.html}}</ref><ref name="IBM2">{{Citeer web| taal = en| last = Ford| first = Neal| title = Java.next: Common ground in Groovy, Scala, and Clojure, Part 1 | work = IBM developerWorks| accessdate = 2013-03-21| date = 2013-03-12| url = http://www.ibm.com/developerworks/library/j-jn2/index.html}}</ref>
* {{US-VLAG}}[[Intel]]<ref name="Intel1">{{Citeer web|taal=en| last = Typesafe| title = Intel hosts Dr. Martin Odersky presenting Scala 2.10 - The Typesafe Blog| accessdate = 2013-03-21| date = 2012-08-31
| url = http://typesafe.com/blog/dr-martin-odersky-presents-scala-210-at-intel}}</ref>
* {{US-VLAG}}[[Nasa]]<ref>{{Citeer web|taal=en| last = Bagwell| first = Phil| title = NASA/JPL Launch DSLs in Scala| accessdate = 2013-01-28| date = 2010-06-20| url = http://www.scala-lang.org/node/6605}}</ref>
* {{US-VLAG}}Quora.com<ref>{{Citeer web|taal=en| last = Seng Tay| first = Kah| title = Is the Quora team considering adopting Scala? Why?| work = Quora| accessdate = 2013-04-04| url = http://www.quora.com/permalink/u5mwI5GC5}}</ref>
* {{NL-VLAG}}Rhinofly<ref>{{Citeer web|taal=nl| title = Rhinofly doet interactieve communicatie| accessdate = 2013-04-19| url = http://www.rhinofly.nl/}}</ref>
* {{US-VLAG}}[[Standard & Poor's|S&P Capital IQ]]<ref>{{Citeer web| taal = en| last = Chiusano| first = Paul| title = Commercial Usage Of Scala At Capital IQ Clari F| location = Boston| accessdate = 2013-02-10| date = 2009-12-02| url = http://www.slideshare.net/bostonscala/commercial-usage-of-scala-at-capital-iq-clari-f}}</ref>
* {{US-VLAG}}StackMob<ref>{{Citeer web|taal=en| last = West| first = Jordan| title = Why StackMob uses Scalaz with Scala| accessdate = 2013-02-11| date = 2011-11-02| url = https://blog.stackmob.com/2011/11/why-stackmob-uses-scalaz-with-scala/}}</ref>
* {{CH-VLAG}}[[UBS]]<ref name="UBS">{{Citeer web|taal=en| interviewer = Andrew Binstock| title = Interview with Scala's Martin Odersky| accessdate = 2012-12-15| date = 2011-07-14| url = http://www.drdobbs.com/architecture-and-design/interview-with-scalas-martin-odersky/231001802}}</ref>
* {{GB-VLAG}}[[Xerox]]<ref>{{Citeer web|taal=en| last = Bagwell| first = Phil| title = Interview with Tim Perrett, an XMPie Scala Developer| accessdate = 2013-02-11| date = 2009-08-26| url = http://www.scala-lang.org/node/2766}}</ref>
|}

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]].<br>
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.<ref name="Twitter1" /><ref name="Twitter2" /><br>LinkedIn gebruikt het [[Scalatra]] [[microframework]] om hun Signal API aan te sturen.<ref name="LinkedIn1" /><br>[[GridGain]] biedt Scala-based DSL for [[cloud computing]] aan.<ref name="GridGain" /><br>[[Foursquare]] gebruikt Scala en [[Lift Web Framework]].<ref name="Foursquare1" /><br>[[Meetup (website)|Meetup]] gebruikt Unfiltered toolkit voor real-time APIs.<ref name="Meetup1" /><ref name="Meetup2" /><br>In april 2011 maakte ''[[The Guardian (Britse krant)|The Guardian]]'' ([http://www.guardian.co.uk/ 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<ref name="Guardian1" /><ref name="Guardian2" />. Deze website heeft de meeste lezers op ''[[The New York Times]]'' na.<ref>{{Citeer nieuws
| last = Reid| first = David
| coauthors = Tania Teixeira
| title = Are people ready to pay for online news?
| work = BBC
| accessdate = 2012-12-15
| date = 2010-02-26
| url = http://news.bbc.co.uk/2/hi/programmes/click_online/8537519.stm
}}</ref>
<br>De Zwitserse bank [[UBS]] heeft Scala goedgekeurd voor gebruik in algemene productie.<ref name="UBS" /><br>[[Remember the Milk]] gebruikt Unfiltered toolkit, Scala and Akka voor hun publieke API en real time updates.<ref name="rememberthemilk" /><br>
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.<ref name="Intel1" />

==Kritiek op Scala==
[[Stephen Colebourne]] - de ontwikkelaar van de alom geroemde [[Joda-Time]]-Java-bibliotheek en hoofdontwikkelaar van de [[Java Community Process|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.<ref>{{Citeer web |taal=en|werk=Stephen Colebourne's blog|url=http://blog.joda.org/2011/11/real-life-scala-feedback-from-yammer.html |titel=Real life Scala feedback from Yammer |auteur=Stephen Colebourne |date=2011-11-29 |bezochtdatum=2012-12-10}}</ref><ref>{{Citeer web |taal=en|url=https://gist.github.com/1406238 |titel=Yammer moving away from Scala |auteur=Coda Hale |date=22 november 2011 |bezochtdatum=10 december 2012}}</ref> Hijzelf en het bedrijf haastte zich om nadere uitleg te geven.<ref>{{Citeer web |taal=en|url=http://codahale.com/the-rest-of-the-story/|titel=The Rest Of The Story |auteur=Coda Hale |date=29 november 2011 |bezochtdatum=10 december 2012}}</ref><ref>{{Citeer web |taal=en|url=http://eng.yammer.com/scala-at-yammer/|titel=Scala at Yammer |auteur=Yammer Engineering |date=1 december 2011 |bezochtdatum=10 december 2012}}</ref> Het bleek een misverstand. Yammer had een performance-probleem en werd niet onmiddellijk op haar wenken bediend 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.<ref>{{Citeer web |taal=en|url=http://typesafe.com/blog/getting-down-to-work/|titel=Practically Speaking |auteur=Typesafe Team |date=30 november 2011 |bezochtdatum=10 december 2012}}</ref>

==Trivia==
* Scala is Italiaans voor trap. In het aanvankelijke en huidige [[Beeldmerk|logo]] is de rode [[Wenteltrap (trap)|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 [[Emacs]]gebruiker. 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<ref name="progfun">{{Citeer web| taal = en| achternaam = Odersky| voornaam = Martin| auteurlink=Martin Odersky| title = Functional Programming Principles in Scala| work = Coursera| accessdate = 2013-03-13| date = 2012-07-17| url = https://www.coursera.org/course/progfun}}</ref> met circa 50.000 inschrijvingen waarvan 9593 al hun opdrachten hebben ingestuurd. Op een afsluitende [[enquête (onderzoek)|enquête]] waren er 166 respondenten uit [[Nederland (hoofdbetekenis)|Nederland]] en 113 uit [[België (hoofdbetekenis)|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<ref>{{Citeer web| taal=en| last = Miller | first = Heather| coauthors = Martin Odersky| title = Functional Programming Principles in Scala: Impressions and Statistics| work = Scala Documentation| accessdate = 2012-12-21| date = 2012-12-20| url = http://docs.scala-lang.org/news/functional-programming-principles-in-scala-impressions-and-statistics.html}}</ref> zijn in een GitHub-repository opgeborgen, samen met het analyserende programma in Scala.<ref>{{Citeer web| taal=en| last = Miller| first = Heather| title = progfun-stats| work = Github Repository| accessdate = 2013-02-08| date = 2012-12-21| url = https://github.com/heathermiller/progfun-stats}}</ref>

== Zie ook ==
[[:Categorie:Software geschreven in Scala]]

== Externe links==
;Officiële website
* {{Citeer web
| lang=en
| title = Introducing Scala
| work = The Scala Programming Language
| accessdate = 2013-03-11
| url = http://www.scala-lang.org/
}}
** {{Citeer web|taal=en
| title = Scala Documentation
| accessdate = 2014-12-01
| url = http://docs.scala-lang.org/
}}
;Typesafe, het commerciële Scala instituut
* {{Citeer web|taal=en
| title = Scala the language
| work = Typesafe Platform
| accessdate = 2014-12-01
| url = http://www.typesafe.com/platform/tools/scala
}}

;[[Cheat sheet]]s
* {{Citeer web|taal=en
| last = O'Connor
| first = Brendan
| title = Scalacheat
| work = Scala Documentation
| accessdate = 2013-01-06
| url = http://docs.scala-lang.org/cheatsheets/
}}
* {{Citeer web|taal=en
| last = Rytz
| first = Lukas
| title = Scala Cheat Sheet
| work = Github Repository
| accessdate = 2013-01-29
| url = https://github.com/lrytz/progfun-wiki/blob/gh-pages/CheatSheet.md
}}
* {{Citeer web|taal=en
| last = Spiewak
| first = Daniel
| coauthors = David Copeland
| title = Scala Style Guide
| work = Scala Documentation
| accessdate = 2013-02-08
| url = http://docs.scala-lang.org/style/
}}

;Gratis Scalacursussen
* {{Citeer web
| lang=nl
| last = Stuurman| first = Sylvia
| title = Opener cursus Scala
| work = Open Universiteit
| accessdate = 2012-12-15
| date = 2011-07-21
| url = http://portal.ou.nl/web/topic-scala/cursus/
}}
* {{Citeer web|taal=de
| last = Paggen
| first = Marcel
| title = ScalaTutorial.de
| accessdate = 2013-03-11
| date = 2013-02-28
| url = http://www.scalatutorial.de/index.html
}}
* {{Citeer web|taal=de
| last = Schäfer
| first = Simon
| title = Scala Tutorial
| work = Scala Tutorial
| accessdate = 2013-01-28
| date = 2012-04-06
| url = http://scalatutorial.wordpress.com/
}}
* {{Citeer web|taal=en
| last = Jenson
| first = Steve
| coauthors = Marius a. Eriksen, Larry Hosken
| title = Scala School!
| accessdate = 2012-12-17
| url = http://twitter.github.io/scala_school/
}}
* {{Citeer web|taal=fr
| last = Einstein++
| title = Apprenez la programmation avec Scala
| work = Le Site du Zéro
| accessdate = 2012-12-16
| date = 2013-01-08
| url = http://www.siteduzero.com/informatique/tutoriels/apprenez-la-programmation-avec-scala
}}
{{Appendix|2=
{{References}}
}}
{{Navigatie programmeertalen}}
{{Navigatie .NET-framework}}

[[Categorie:Scala (programmeertaal)| ]]
[[Categorie:.NET framework]]
[[Categorie:Functionele programmeertaal]]
[[Categorie:Multi-paradigma programmeertaal]]