Scala (lenguaje de programación)

Scala.js es un compilador de Scala que compila a JavaScript, lo que permite escribir programas Scala que pueden ejecutarse en navegadores web o Node.js. ^{[ 24 ]} El compilador, en desarrollo desde 2013, dejó de ser experimental en 2015 (v0.6). La versión v1.0.0-M1 se lanzó en junio de 2018 y la versión 1.1.1 en septiembre de2020. ^{[ 25 ]}

Scala Native es un compilador de Scala que se dirige a la infraestructura del compilador LLVM para crear código ejecutable que utiliza un entorno de ejecución gestionado ligero, el cual emplea el recolector de basura Boehm . El proyecto está liderado por Denys Shabalin y su primera versión, la 0.1, se lanzó el 14 de marzo de 2017. El desarrollo de Scala Native comenzó en 2015 con el objetivo de ser más rápido que la compilación justo a tiempo para la JVM, eliminando la compilación inicial del código en tiempo de ejecución y proporcionando además la capacidad de llamar directamente a rutinas nativas. ^{[ 26 ] [ 27 ]}

En junio de 2004 se publicó un compilador de referencia de Scala dirigido al .NET Framework y su Common Language Runtime , ^{[ 14 ]} pero se abandonó oficialmente en 2012. ^{[ 28 ]}

El programa "Hola Mundo" escrito en Scala 3 tiene esta forma:

@main def main () = println ( "Hola, Mundo!" )

A diferencia de la aplicación independiente Hello World para Java , no hay declaración de clase y nada se declara como estático.

Cuando el programa se almacena en el archivo HelloWorld.scala , el usuario lo compila con el comando:

$ scalac HelloWorld.scala

y lo ejecuta con

$ scala HolaMundo

Esto es análogo al proceso de compilación y ejecución de código Java. De hecho, el modelo de compilación y ejecución de Scala es idéntico al de Java, lo que lo hace compatible con herramientas de compilación de Java como Apache Ant .

Una versión más corta del programa "Hola Mundo" en Scala es:

println ( "Hola, mundo!" )

Scala incluye un intérprete de comandos interactivo y soporte para scripts. ^{[ 29 ]} Guardado en un archivo llamado HelloWorld2.scala, esto se puede ejecutar como un script usando el comando:

$ scala HelloWorld2.scala

Los comandos también se pueden introducir directamente en el intérprete de Scala, utilizando la opción -e :

$ scala -e 'println("¡Hola, mundo!")'

Las expresiones se pueden introducir de forma interactiva en el REPL :

$ scala Bienvenido a Scala 2.12.2 (Java HotSpot(TM) 64-Bit Server VM, Java 1.8.0_131). Escriba expresiones para su evaluación. O pruebe :help.scala> List(1, 2, 3).map(x => x * x) res0: List[Int] = List(1, 4, 9)scala>

El siguiente ejemplo muestra las diferencias entre la sintaxis de Java y Scala. La función mathFunction toma un entero, lo eleva al cuadrado y luego suma la raíz cúbica de ese número al logaritmo natural de ese número, devolviendo el resultado (es decir,${\displaystyle n^{2/3}+\ln(n^{2})}$):

Algunas diferencias sintácticas en este código son:

• Scala no requiere punto y coma (;) para finalizar las sentencias.
• Los tipos de valor se escriben con mayúscula inicial (mayúsculas): Int, Double, Booleanen lugar de int, double, boolean.
• Los tipos de parámetros y de retorno siguen, como en Pascal , en lugar de preceder como en C.
• Los métodos deben ir precedidos de def.
• Las variables locales o de clase deben ir precedidas de val(indica una variable inmutablevar ) o (indica una variable mutable ).
• El returnoperador es innecesario en una función (aunque está permitido); el valor de la última instrucción o expresión ejecutada es normalmente el valor de la función.
• En lugar del operador de conversión de Java (Type) foo, Scala utiliza foo.asInstanceOf[Type], o una función especializada como toDoubleo toInt.
• La función o método foo()también puede llamarse simplemente como foo; el método thread.send(signo)también puede llamarse simplemente como thread send signo; y el método foo.toString()también puede llamarse simplemente como foo toString.

Estas relajaciones sintácticas están diseñadas para permitir la compatibilidad con lenguajes específicos de dominio .

Otras diferencias sintácticas básicas:

• Las referencias a arrays se escriben como llamadas a funciones, por ejemplo, array(i)en lugar de array[i]. (Internamente en Scala, la primera se expande en array.apply(i), que devuelve la referencia).
• Los tipos genéricos se escriben como , por ejemplo, List[String]en lugar de como en Java .List<String>
• En lugar del pseudotipo void, Scala tiene la clase singletonUnit real (ver más abajo).

El siguiente ejemplo contrasta la definición de clases en Java y Scala.

El código anterior muestra algunas de las diferencias conceptuales entre el manejo de clases en Java y Scala:

• Scala no tiene variables ni métodos estáticos. En su lugar, tiene objetos singleton , que son esencialmente clases con una sola instancia. Los objetos singleton se declaran usando objecten lugar de class. Es común colocar variables y métodos estáticos en un objeto singleton con el mismo nombre que la clase, que entonces se conoce como objeto compañero . ^{[ 15 ]} (La clase subyacente para el objeto singleton tiene un $añadido. Por lo tanto, para class Foocon objeto compañero object Foo, internamente hay una clase Foo$que contiene el código del objeto compañero, y se crea un objeto de esta clase, usando el patrón singleton .)
• En lugar de parámetros de constructor, Scala tiene parámetros de clase , que se colocan en la clase, de forma similar a los parámetros de una función. Cuando se declaran con un modificador valo var, los campos también se definen con el mismo nombre y se inicializan automáticamente a partir de los parámetros de clase. (Internamente, el acceso externo a los campos públicos siempre se realiza a través de métodos de acceso (getter) y modificación (setter), que se crean automáticamente. La función de acceso tiene el mismo nombre que el campo, por lo que en el ejemplo anterior no es necesario declarar explícitamente los métodos de acceso). También se pueden declarar constructores alternativos, como en Java. El código que iría en el constructor predeterminado (excepto la inicialización de las variables miembro) va directamente a nivel de clase.
• En Scala es posible definir operadores usando símbolos como nombres de métodos. En lugar de addPoint, el ejemplo de Scala define +=, que luego se invoca con notación infija como grid += this.
• La visibilidad predeterminada en Scala es public.

Como se mencionó anteriormente, Scala tiene una gran flexibilidad sintáctica en comparación con Java. A continuación se muestran algunos ejemplos:

• Los puntos y comas no son necesarios; las líneas se unen automáticamente si comienzan o terminan con un carácter que normalmente no puede aparecer en esa posición, o si hay paréntesis o corchetes sin cerrar.
• Cualquier método puede usarse como operador infijo , por ejemplo "%d apples".format(num), y "%d apples" format numson equivalentes. De hecho, los operadores aritméticos como +y se tratan igual que cualquier otro método, ya que los nombres de las funciones pueden constar de secuencias de símbolos arbitrarios (con algunas excepciones para elementos como paréntesis, corchetes y llaves que deben manejarse de forma especial); el único tratamiento especial que reciben estos métodos con nombres de símbolos se refiere al manejo de la precedencia.<<
• Los métodos applyy updatetienen formas abreviadas sintácticas. foo()—donde fooes un valor (objeto singleton o instancia de clase)— es abreviatura de foo.apply(), y foo() = 42es abreviatura de foo.update(42). De manera similar, foo(42)es abreviatura de foo.apply(42), y foo(4) = 2es abreviatura de foo.update(4, 2). Esto se usa para clases de colección y se extiende a muchos otros casos, como celdas STM .
• Scala distingue entre métodos sin paréntesis ( def foo = 42) y def foo() = 42métodos con paréntesis vacíos ( ). Al llamar a un método con paréntesis vacíos, se pueden omitir los paréntesis, lo cual es útil al llamar a bibliotecas Java que no conocen esta distinción, por ejemplo, usando foo.toStringen lugar de foo.toString(). Por convención, un método debe definirse con paréntesis vacíos cuando realiza efectos secundarios .
• Los nombres de métodos que terminan en dos puntos ( :) esperan el argumento en el lado izquierdo y el receptor en el lado derecho. Por ejemplo, es lo mismo que , la primera forma corresponde visualmente al resultado (una lista con el primer elemento 4 y el segundo elemento 2).4 :: 2 :: NilNil.::(2).::(4)
• Las variables del cuerpo de la clase se pueden implementar de forma transparente como métodos getter y setter separados. Para trait FooLike { var bar: Int }, una implementación puede ser . El sitio de llamada aún podrá usar un conciso .objectFooextendsFooLike{privatevarx=0;defbar=x;defbar_=(value:Int){x=value}}}}foo.bar = 42
• Se permite el uso de llaves en lugar de paréntesis en las llamadas a métodos. Esto permite implementaciones de biblioteca puras de nuevas estructuras de control. ^{[ 31 ]} Por ejemplo, breakable { ... if (...) break() ... }parece que breakablefuera una palabra clave definida por el lenguaje, pero en realidad es solo un método que toma un argumento thunk . Los métodos que toman thunks o funciones a menudo los colocan en una segunda lista de parámetros, lo que permite mezclar la sintaxis de paréntesis y llaves: Vector.fill(4) { math.random }es lo mismo que Vector.fill(4)(math.random). La variante de llaves permite que la expresión abarque varias líneas.
• Las expresiones For (que se explican más adelante) pueden acomodar cualquier tipo que defina métodos monádicos como map, flatMapy filter.

Individualmente, estas opciones pueden parecer cuestionables, pero en conjunto permiten definir lenguajes específicos de dominio en Scala sin necesidad de extender el compilador. Por ejemplo, la sintaxis especial de Erlang para enviar un mensaje a un actor, ie , puede implementarse (y de hecho se implementa) en una biblioteca de Scala sin necesidad de extensiones del lenguaje.actor ! message

Java establece una clara distinción entre tipos primitivos (por ejemplo, inty boolean) y tipos de referencia (cualquier clase ). Solo los tipos de referencia forman parte del esquema de herencia, que deriva de java.lang.Object. En Scala, todos los tipos heredan de una clase de nivel superior Any, cuyos hijos inmediatos son AnyVal(tipos de valor, como Inty Boolean) y AnyRef(tipos de referencia, como en Java). Esto significa que la distinción de Java entre tipos primitivos y tipos encapsulados (por ejemplo, intvs. Integer) no está presente en Scala; el encapsulado y desempaquetado es completamente transparente para el usuario. Scala 2.10 permite que el usuario defina nuevos tipos de valor.

En lugar de los bucles " foreach " de Java para recorrer un iterador, Scala tiene forexpresiones for, que son similares a las comprensiones de listas en lenguajes como Haskell , o una combinación de comprensiones de listas y expresiones generadoras en Python . Las expresiones for que usan la yieldpalabra clave permiten generar una nueva colecciónmap iterando sobre una existente, devolviendo una nueva colección del mismo tipo. El compilador las traduce en una serie de llamadas a , flatMapy filter. Cuando yieldno se usa , el código se aproxima a un bucle de estilo imperativo, traduciéndolo a foreach.

Un ejemplo sencillo es:

val s = para ( x <- 1 a 25 si x * x > 50 ) produce 2 * x

El resultado de ejecutarlo es el siguiente vector:

Vector(16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50)

(La expresión 1 to 25no es una sintaxis especial. El método toestá definido en la biblioteca estándar de Scala como un método de extensión para enteros, utilizando una técnica conocida como conversiones implícitas ^{[ 32 ]} que permite agregar nuevos métodos a tipos existentes).

Un ejemplo más complejo de iteración sobre un mapa es:

// Dado un mapa que especifica los usuarios de Twitter mencionados en un conjunto de tweets, // y el número de veces que se mencionó a cada usuario, busca a los usuarios // en un mapa de políticos conocidos y devuelve un nuevo mapa que muestra solo a los // políticos demócratas (como objetos, en lugar de cadenas). val dem_mentions = for ( mention , times ) <- mentions account <- accounts . get ( mention ) if account . party == "Democratic" yield ( account , times )

La expresión es un ejemplo de coincidencia de patrones (ver más abajo). Iterar sobre un mapa devuelve un conjunto de tuplas clave-valor , y la coincidencia de patrones permite desestructurar fácilmente las tuplas en variables separadas para la clave y el valor. De manera similar, el resultado de la comprensión también devuelve tuplas clave-valor, que se reconstruyen automáticamente en un mapa porque el objeto de origen (de la variable ) es un mapa. Si en cambio contuviera una lista, un conjunto, una matriz u otra colección de tuplas, exactamente el mismo código anterior produciría una nueva colección del mismo tipo.(mention, times) <- mentionsmentionsmentions

Si bien Scala admite todas las características de la programación orientada a objetos disponibles en Java (e incluso las amplía de diversas maneras), también ofrece una gran cantidad de funcionalidades que normalmente solo se encuentran en lenguajes de programación funcional . En conjunto, estas características permiten escribir programas en Scala con un estilo casi completamente funcional y, además, permiten combinar estilos funcionales y orientados a objetos.

Algunos ejemplos son:

• No hay distinción entre enunciados y expresiones.
• Inferencia de tipo
• Funciones anónimas con semántica de captura (es decir, cierres )
• Variables y objetos inmutables
• Evaluación perezosa
• Continuaciones delimitadas (desde la versión 2.8)
• Funciones de orden superior
• Funciones anidadas
• Zurra
• Coincidencia de patrones
• Tipos de datos algebraicos (mediante clases de casos )
• Tuplas

def printValue ( x : String ): Unit = println ( "Comí un %s" . format ( x ))

def printValue ( x : String ) = println ( "Comí un %s" format x )

def formatApples ( x : Int ) = "Comí %d manzanas " .format ( x )

def factorial ( x : Int ): Int = if x == 0 then 1 else x * factorial ( x - 1 )

def factorial ( n : Int ): Int = if n == 0 then 1 else n * factorial ( n - 1 )

@tailrec def factorial ( n : Int , accum : Int ): Int = si n == 0 entonces accum else factorial ( n - 1 , n * accum )

def factorial ( n : Int ): Int =@tailrecdef bucle ( actual : Int , acumulado : Int ): Int =Si la corriente es igual a 0 , entonces el acumuladorelse bucle ( actual - 1 , actual * acumulado )bucle ( n , 1 ) // Llamada al cierre usando el caso basefactorial final

def qsort ( lista : Lista [ Int ]): Lista [ Int ] = lista coincidencia caso Nil => Nil caso pivot :: cola => val ( más pequeño , resto ) = cola . partición ( _ < pivot ) qsort ( más pequeño ) ::: pivot :: qsort ( resto )

try ... catch case nfe : NumberFormatException => { println ( nfe ); List ( 0 ) } case _ => Nil

val qsort : List [ Int ] => List [ Int ] = case Nil => Nil case pivot :: tail => val ( smaller , rest ) = tail . partition ( _ < pivot ) qsort ( smaller ) ::: pivot :: qsort ( rest )

scala > qsort ( Lista ( 6 , 2 , 5 , 9 )) res32 : Lista [ Int ] = Lista ( 2 , 5 , 6 , 9 )

Scala es un lenguaje puramente orientado a objetos, en el sentido de que cada valor es un objeto . Los tipos de datos y los comportamientos de los objetos se describen mediante clases y rasgos . Las abstracciones de clase se extienden mediante la herencia y un mecanismo de composición flexible basado en mixins para evitar los problemas de la herencia múltiple .

Los traits son el reemplazo de las interfaces de Java en Scala . Las interfaces en las versiones de Java anteriores a la 8 son muy restringidas y solo pueden contener declaraciones de funciones abstractas. Esto ha generado críticas, ya que proporcionar métodos de conveniencia en las interfaces resulta engorroso (los mismos métodos deben reimplementarse en cada implementación) y extender una interfaz publicada de forma retrocompatible es imposible. Los traits son similares a las clases mixin , pues poseen casi toda la potencia de una clase abstracta regular, careciendo únicamente de parámetros de clase (el equivalente en Scala a los parámetros del constructor de Java), dado que los traits siempre se integran con una clase. El superoperador `component` se comporta de manera especial en los traits, permitiendo encadenarlos mediante composición, además de la herencia. El siguiente ejemplo muestra un sistema de ventanas simple:

clase abstracta Ventana : // función abstracta dibujar ()clase SimpleWindow extiende Window : def draw () println ( "en SimpleWindow" ) // dibuja una ventana básicaEl rasgo WindowDecoration extiende Windowtrait HorizontalScrollbarDecoration extends WindowDecoration : // Se necesita una "sobreescritura abstracta" aquí para que "super()" funcione porque la función padre // es abstracta. Si fuera concreta, una "sobreescritura" normal sería suficiente. abstract override def draw ( ) println ( "en HorizontalScrollbarDecoration" ) super.draw ( ) // ahora dibuja una barra de desplazamiento horizontaltrait VerticalScrollbarDecoration extends WindowDecoration : abstract override def draw () println ( "en VerticalScrollbarDecoration" ) super . draw () // ahora dibuja una barra de desplazamiento verticaltrait TitleDecoration extends WindowDecoration : abstract override def draw () println ( "en TitleDecoration" ) super . draw () // ahora dibuja la barra de título

Una variable puede declararse de la siguiente manera:

val mywin = new SimpleWindow with VerticalScrollbarDecoration with HorizontalScrollbarDecoration with TitleDecoration

El resultado de la llamada mywin.draw()es:

en TitleDecoration en HorizontalScrollbarDecoration en VerticalScrollbarDecoration en SimpleWindow

En otras palabras, la llamada drawprimero ejecutó el código en TitleDecoration(el último rasgo mezclado), luego (a través de las super()llamadas) volvió a través de los otros rasgos mezclados y finalmente al código en Window, aunque ninguno de los rasgos heredaba de otro . Esto es similar al patrón decorador , pero es más conciso y menos propenso a errores, ya que no requiere encapsular explícitamente la ventana principal, reenviar explícitamente funciones cuya implementación no se modifica, o depender de la inicialización en tiempo de ejecución de las relaciones de entidad. En otros lenguajes, se podría lograr un efecto similar en tiempo de compilación con una larga cadena lineal de herencia de implementación , pero con la desventaja en comparación con Scala de que habría que declarar una cadena de herencia lineal para cada posible combinación de los mix-ins.

Scala is equipped with an expressive static type system that mostly enforces the safe and coherent use of abstractions. The type system is, however, not sound.^[38] In particular, the type system supports:

• Classes and abstract types as object members
• Structural types
• Path-dependent types
• Compound types
• Explicitly typed self references
• Generic classes
• Polymorphic methods
• Upper and lower type bounds
• Variance
• Annotation
• Views

Scala is able to infer types by use. This makes most static type declarations optional. Static types need not be explicitly declared unless a compiler error indicates the need. In practice, some static type declarations are included for the sake of code clarity.

A common technique in Scala, known as "enrich my library"^[39] (originally termed "pimp my library" by Martin Odersky in 2006;^[32] concerns were raised about this phrasing due to its negative connotations^[40] and immaturity^[41]), allows new methods to be used as if they were added to existing types. This is similar to the C# concept of extension methods but more powerful, because the technique is not limited to adding methods and can, for instance, be used to implement new interfaces. In Scala, this technique involves declaring an implicit conversion from the type "receiving" the method to a new type (typically, a class) that wraps the original type and provides the additional method. If a method cannot be found for a given type, the compiler automatically searches for any applicable implicit conversions to types that provide the method in question.

This technique allows new methods to be added to an existing class using an add-on library such that only code that imports the add-on library gets the new functionality, and all other code is unaffected.

The following example shows the enrichment of type Int with methods isEven and isOdd:

objectMyExtensions:extension(i:Int)defisEven=i%2==0defisOdd=!i.isEvenimportMyExtensions.*// bring implicit enrichment into scope4.isEven// -> true

Importing the members of MyExtensions brings the implicit conversion to extension class IntPredicates into scope.^[42]

En 2013, cuando Scala estaba en la versión 2.10, el ThoughtWorks Technology Radar, que es un informe semestral basado en la opinión de un grupo de tecnólogos sénior, ^{[ 156 ]} recomendó la adopción de Scala en su categoría de lenguajes y marcos. ^{[ 157 ]}

En julio de 2014, esta evaluación se hizo más específica y ahora se refiere a "Scala, las partes buenas", que se describe como "Para usar Scala con éxito, necesitas investigar el lenguaje y tener una opinión muy firme sobre qué partes son adecuadas para ti, creando tu propia definición de Scala, las partes buenas". ^{[ 158 ]}

En la edición de 2018 de la encuesta State of Java , ^{[ 159 ]} que recopiló datos de 5160 desarrolladores sobre varios temas relacionados con Java, Scala ocupa el tercer lugar en términos de uso de lenguajes alternativos en la JVM . En relación con la edición del año anterior de la encuesta, el uso de Scala entre los lenguajes alternativos de la JVM cayó del 28,4% al 21,5%, superado por Kotlin , que subió del 11,4% en 2017 al 28,8% en 2018. El Índice de Popularidad de Lenguajes de Programación, ^{[ 160 ]} que rastrea las búsquedas de tutoriales de lenguajes, clasificó a Scala en el puesto 15 en abril de 2018 con una pequeña tendencia a la baja, y en el puesto 17 en enero de 2021. Esto convierte a Scala en el tercer lenguaje basado en JVM más popular después de Java y Kotlin, clasificado en el puesto 12.

El ranking de lenguajes de programación RedMonk , que establece clasificaciones basadas en el número de proyectos de GitHub y preguntas formuladas en Stack Overflow , clasificó a Scala en el puesto 14 en enero de 2021. ^{[ 161 ]} Aquí, Scala se ubicó dentro de un grupo de lenguajes de segundo nivel, por delante de Go , PowerShell y Haskell, y por detrás de Swift , Objective-C , TypeScript y R.

El índice TIOBE ^{[ 162 ]} de popularidad de lenguajes de programación utiliza clasificaciones de motores de búsqueda de internet y recuentos de publicaciones similares para determinar la popularidad de un lenguaje. En septiembre de 2021, Scala ocupaba el puesto 31. En esta clasificación, Scala estaba por delante de Haskell (puesto 38) y Erlang , pero por debajo de Go (puesto 14), Swift (puesto 15) y Perl (puesto 19).

A partir de 2022Los lenguajes basados ​​en JVM, como Clojure, Groovy y Scala, tienen una alta clasificación, pero aún son significativamente menos populares que el lenguaje Java original , que generalmente se ubica entre los tres primeros puestos. ^{[ 161 ] [ 162 ]}

• En abril de 2009, Twitter anunció que había cambiado gran parte de su backend de Ruby a Scala y que tenía la intención de convertir el resto. ^{[ 163 ]}
• Tesla, Inc. utiliza Akka con Scala en el backend de la planta de energía virtual de Tesla. De este modo, el modelo Actor se utiliza para representar y operar los dispositivos que, junto con otros componentes, conforman una instancia de la planta de energía virtual, y los flujos reactivos se utilizan para la recopilación y el procesamiento de datos. ^{[ 164 ]}
• Apache Kafka está implementado en Scala en lo que respecta a la mayor parte de su núcleo y otras partes críticas. Se mantiene y amplía a través del proyecto de código abierto y por la empresa Confluent. ^{[ 165 ]}
• Gilt utiliza Scala y Play Framework . ^{[ 166 ]}
• Foursquare utiliza Scala y Lift . ^{[ 167 ]}
• Coursera utiliza Scala y Play Framework . ^{[ 168 ]}
• Apple Inc. utiliza Scala en ciertos equipos, junto con Java y el framework Play. ^{[ 169 ] [ 170 ]}
• El sitio web de alto tráfico del periódico The Guardian , guardian.co.uk ^{[ 171 ]} , anunció en abril de 2011 que estaba cambiando de Java a Scala. ^{[ 172 ] [ 173 ]}
• El New York Times reveló en 2014 que su sistema interno de gestión de contenido Blackbeard está construido utilizando Scala, Akka y Play. ^{[ 174 ]}
• El periódico Huffington Post comenzó a utilizar Scala como parte de su sistema de entrega de contenido Athena en 2013. ^{[ 175 ]}
• El banco suizo UBS aprobó Scala para su uso general en producción. ^{[ 176 ]}
• LinkedIn utiliza el microframework Scalatra para potenciar su API Signal. ^{[ 177 ]}
• Meetup utiliza el kit de herramientas Unfiltered para API en tiempo real. ^{[ 178 ]}
• Remember the Milk utiliza el kit de herramientas Unfiltered, Scala y Akka para la API pública y las actualizaciones en tiempo real. ^{[ 179 ]}
• Verizon busca crear "un marco de próxima generación" utilizando Scala. ^{[ 180 ]}
• Airbnb desarrolla el software de aprendizaje automático de código abierto "Aerosolve", escrito en Java y Scala. ^{[ 181 ]}
• Zalando cambió su pila tecnológica de Java a Scala y Play. ^{[ 182 ]}
• SoundCloud utiliza Scala para su backend, empleando tecnologías como Finagle (microservicios), ^{[ 183 ]} Scalding y Spark (procesamiento de datos). ^{[ 184 ]}
• Databricks utiliza Scala para la plataforma de Big Data Apache Spark .
• Morgan Stanley utiliza Scala de forma extensiva en sus proyectos relacionados con finanzas y activos. ^{[ 185 ]}
• Hay equipos dentro de Google y Alphabet Inc. que utilizan Scala, principalmente debido a adquisiciones como Firebase ^{[ 186 ]} y Nest. ^{[ 187 ]}
• Walmart Canadá utiliza Scala para su plataforma de back-end. ^{[ 188 ]}
• Duolingo utiliza Scala para su módulo de back-end que genera lecciones. ^{[ 189 ]}
• HMRC utiliza Scala para muchas aplicaciones tributarias del Gobierno del Reino Unido. ^{[ 190 ]}
• M1 Finance utiliza Scala para su plataforma de back-end. ^{[ 191 ]}
• Lichess utiliza Scala para las aplicaciones principales de su plataforma de código abierto. ^{[ 192 ]}