Back

ⓘ Scala (programming language)




Scala (programming language)
                                     

ⓘ Scala (programming language)

Scala is a general-purpose programming language providing support for functional programming and a strong static type system. Designed to be concise, many of Scalas design decisions aimed to address criticisms of Java.

Scala source code is intended to be compiled to Java bytecode, so that the resulting executable code runs on a Java virtual machine. Scala provides language interoperability with Java, so that libraries written in either language may be referenced directly in Scala or Java code. Like Java, Scala is object-oriented, and uses a curly-brace syntax reminiscent of the C programming language. Unlike Java, Scala has many features of functional programming languages like Scheme, Standard ML and Haskell, including currying, immutability, lazy evaluation, and pattern matching. It also has an advanced type system supporting algebraic data types, covariance and contravariance, higher-order types but not higher-rank types, and anonymous types. Other features of Scala not present in Java include operator overloading, optional parameters, named parameters, and raw strings. Conversely, a feature of Java not in Scala is checked exceptions, which has proved controversial.

The name Scala is a portmanteau of scalable and language, signifying that it is designed to grow with the demands of its users.

                                     

1. History

The design of Scala started in 2001 at the Ecole Polytechnique Federale de Lausanne EPFL in Lausanne, Switzerland by Martin Odersky. It followed on from work on Funnel, a programming language combining ideas from functional programming and Petri nets. Odersky formerly worked on Generic Java, and javac, Suns Java compiler.

After an internal release in late 2003, Scala was released publicly in early 2004 on the Java platform, A second version v2.0 followed in March 2006.

On 17 January 2011, the Scala team won a five-year research grant of over €2.3 million from the European Research Council. On 12 May 2011, Odersky and collaborators launched Typesafe Inc. later renamed Lightbend Inc., a company to provide commercial support, training, and services for Scala. Typesafe received a $3 million investment in 2011 from Greylock Partners.

                                     

2. Platforms and license

Scala runs on the Java platform Java virtual machine and is compatible with existing Java programs. As Android applications are typically written in Java and translated from Java bytecode into Dalvik bytecode which may be further translated to native machine code during installation when packaged, Scalas Java compatibility makes it well-suited to Android development, more so when a functional approach is preferred.

The reference Scala software distribution, including compiler and libraries, is released under the Apache license.

                                     

2.1. Platforms and license Other compilers and targets

Scala.js is a Scala compiler that compiles to JavaScript, making it possible to write Scala programs that can run in web browsers or Node.js. The compiler was in development since 2013, was announced as no longer experimental in 2015 v0.6. Version v1.0.0-M1 was released in June 2018, but in 2019 was still as M7.

Scala Native is a Scala compiler that targets the LLVM compiler infrastructure to create executable code that uses a lightweight managed runtime, which uses the Boehm garbage collector. The project is led by Denys Shabalin and had its first release, 0.1, on 14 March 2017. Development of Scala Native began in 2015 with a goal of being faster than just-in-time compilation for the JVM by eliminating the initial runtime compilation of code and also providing the ability to call native routines directly.

A reference Scala compiler targeting the.NET Framework and its Common Language Runtime was released in June 2004, but was officially dropped in 2012.



                                     

3.1. Examples "Hello World" example

The Hello World program written in Scala has this form:

Unlike the stand-alone Hello World application for Java, there is no class declaration and nothing is declared to be static; a singleton object created with the object keyword is used instead.

When the program is stored in file HelloWorld.scala, the user compiles it with the command:

$ scalac HelloWorld.scala

and runs it with

$ scala HelloWorld

This is analogous to the process for compiling and running Java code. Indeed, Scalas compiling and executing model is identical to that of Java, making it compatible with Java build tools such as Apache Ant.

A shorter version of the "Hello World" Scala program is:

Scala includes interactive shell and scripting support. Saved in a file named HelloWorld2.scala, this can be run as a script with no prior compiling using:

$ scala HelloWorld2.scala

Commands can also be entered directly into the Scala interpreter, using the option -e:

$ scala -e println"Hello, World!"

Expressions can be entered interactively in the REPL:

                                     

3.2. Examples Basic example

The following example shows the differences between Java and Scala syntax:

Some syntactic differences in this code are:

  • The return operator is unnecessary in a function although allowed; the value of the last executed statement or expression is normally the functions value.
  • Parameter and return types follow, as in Pascal, rather than precede as in C.
  • Methods must be preceded by def.
  • Value types are capitalized: Int, Double, Boolean instead of int, double, boolean.
  • Scala does not require semicolons to end statements.
  • Local or class variables must be preceded by val indicates an immutable variable or var indicates a mutable variable.
  • Instead of the pseudo-type void, Scala has the actual singleton class Unit see below.
  • Instead of the Java cast operator Type foo, Scala uses foo.asInstanceOf rather than Javas List.
                                     

3.3. Examples Example with classes

The following example contrasts the definition of classes in Java and Scala.

The code above shows some of the conceptual differences between Java and Scalas handling of classes:

  • Default visibility in Scala is public.
  • In place of constructor parameters, Scala has class parameters, which are placed on the class, similar to parameters to a function. When declared with a val or var modifier, fields are also defined with the same name, and automatically initialized from the class parameters. Under the hood, external access to public fields always goes through accessor getter and mutator setter methods, which are automatically created. The accessor function has the same name as the field, which is why its unnecessary in the above example to explicitly declare accessor methods) Note that alternative constructors can also be declared, as in Java. Code that would go into the default constructor other than initializing the member variables goes directly at class level.
  • Scala has no static variables or methods. Instead, it has singleton objects, which are essentially classes with only one instance. Singleton objects are declared using object instead of class. It is common to place static variables and methods in a singleton object with the same name as the class name, which is then known as a companion object.


                                     

4. Features with reference to Java

Scala has the same compiling model as Java and C#, namely separate compiling and dynamic class loading, so that Scala code can call Java libraries.

Scalas operational characteristics are the same as Javas. The Scala compiler generates byte code that is nearly identical to that generated by the Java compiler. In fact, Scala code can be decompiled to readable Java code, with the exception of certain constructor operations. To the Java virtual machine JVM, Scala code and Java code are indistinguishable. The only difference is one extra runtime library, scala-library.jar.

Scala adds a large number of features compared with Java, and has some fundamental differences in its underlying model of expressions and types, which make the language theoretically cleaner and eliminate several corner cases in Java. From the Scala perspective, this is practically important because several added features in Scala are also available in C#. Examples include:

                                     

4.1. Features with reference to Java Syntactic flexibility

As mentioned above, Scala has a good deal of syntactic flexibility, compared with Java. The following are some examples:

  • Method names ending in colon: expect the argument on the left-hand-side and the receiver on the right-hand-side. For example, the 4 2 Nil is the same as Nil. 2. 4, the first form corresponding visually to the result a list with first element 4 and second element 2.
  • The use of curly braces instead of parentheses is allowed in method calls. This allows pure library implementations of new control structures. For example, breakable {. if. break. } looks as if breakable was a language defined keyword, but really is just a method taking a thunk argument. Methods that take thunks or functions often place these in a second parameter list, allowing to mix parentheses and curly braces syntax: Vector.fill4 { math.random } is the same as Vector.fill4math.random. The curly braces variant allows the expression to span multiple lines.
  • Methods apply and update have syntactic short forms. foo - where foo is a value singleton object or class instance - is short for foo.apply, and foo = 42 is short for foo.update42. Similarly, foo42 is short for foo.apply42, and foo4 = 2 is short for foo.update4, 2. This is used for collection classes and extends to many other cases, such as STM cells.
  • Scala distinguishes between no-parens def foo = 42 and empty-parens def foo = 42 methods. When calling an empty-parens method, the parentheses may be omitted, which is useful when calling into Java libraries that do not know this distinction, e.g., using foo.toString instead of foo.toString. By convention, a method should be defined with empty-parens when it performs side effects.
  • Any method can be used as an infix operator, e.g. "%d apples".formatnum and "%d apples" format num are equivalent. In fact, arithmetic operators like + and < < are treated just like any other methods, since function names are allowed to consist of sequences of arbitrary symbols with a few exceptions made for things like parens, brackets and braces that must be handled specially; the only special treatment that such symbol-named methods undergo concerns the handling of precedence.
  • Semicolons are unnecessary; lines are automatically joined if they begin or end with a token that cannot normally come in this position, or if there are unclosed parentheses or brackets.
  • Class body variables can be transparently implemented as separate getter and setter methods. For trait FooLike { var bar: Int }, an implementation may be object Foo extends FooLike { private var x = 0 ; def bar = x ; def bar_= value: Int { x = value }} } }. The call site will still be able to use a concise foo.bar = 42.
  • For-expressions explained further down can accommodate any type that defines monadic methods such as map, flatMap and filter.

By themselves, these may seem like questionable choices, but collectively they serve the purpose of allowing domain-specific languages to be defined in Scala without needing to extend the compiler. For example, Erlangs special syntax for sending a message to an actor, i.e. actor! message can be and is implemented in a Scala library without needing language extensions.

                                     

4.2. Features with reference to Java Unified type system

Java makes a sharp distinction between primitive types e.g. int and boolean and reference types any class. Only reference types are part of the inheritance scheme, deriving from java.lang.Object. In Scala, all types inherit from a top-level class Any, whose immediate children are AnyVal value types, such as Int and Boolean and AnyRef reference types, as in Java. This means that the Java distinction between primitive types and boxed types e.g. int vs. Integer is not present in Scala; boxing and unboxing is completely transparent to the user. Scala 2.10 allows for new value types to be defined by the user.

                                     

4.3. Features with reference to Java For-expressions

Instead of the Java "foreach" loops for looping through an iterator, Scala has for -expressions, which are similar to list comprehensions in languages such as Haskell, or a combination of list comprehensions and generator expressions in Python. For-expressions using the yield keyword allow a new collection to be generated by iterating over an existing one, returning a new collection of the same type. They are translated by the compiler into a series of map, flatMap and filter calls. Where yield is not used, the code approximates to an imperative-style loop, by translating to foreach.

A simple example is:

The result of running it is the following vector:

Vector16, 18, 20, 22, 24, 26, 28, 30, 32, 34, 36, 38, 40, 42, 44, 46, 48, 50

Note that the expression 1 to 25 is not special syntax. The method to is rather defined in the standard Scala library as an extension method on integers, using a technique known as implicit conversions that allows new methods to be added to existing types.

A more complex example of iterating over a map is:

Expression mention, times x < 2, which specifies a function with one parameter, that compares its argument to see if it is less than 2. It is equivalent to the Lisp form lambda x < x 2). Note that neither the type of x nor the return type need be explicitly specified, and can generally be inferred by type inference; but they can be explicitly specified, e.g. as x: Int => x < 2 or even x: Int => x < 2: Boolean.

Anonymous functions behave as true closures in that they automatically capture any variables that are lexically available in the environment of the enclosing function. Those variables will be available even after the enclosing function returns, and unlike in the case of Javas anonymous inner classes do not need to be declared as final. It is even possible to modify such variables if they are mutable, and the modified value will be available the next time the anonymous function is called.

An even shorter form of anonymous function uses placeholder variables: For example, the following:

list map { x => sqrtx }

can be written more concisely as

list map { sqrt_ }

or even

list map sqrt


                                     

4.4. Features with reference to Java Immutability

Scala enforces a distinction between immutable unmodifiable, read-only variables, whose value cannot be changed once assigned, and mutable variables, which can be changed. A similar distinction is made between immutable and mutable objects. The distinction must be made when a variable is declared: Immutable variables are declared with val while mutable variables use var. Similarly, all of the collection objects container types in Scala, e.g. linked lists, arrays, sets and hash tables, are available in mutable and immutable variants, with the immutable variant considered the more basic and default implementation. The immutable variants are "persistent" data types in that they create a new object that encloses the old object and adds the new members; this is similar to how linked lists are built up in Lisp, where elements are prepended by creating a new "cons" cell with a pointer to the new element the "head" and the old list the "tail". This allows for very easy concurrency - no locks are needed as no shared objects are ever modified. Immutable structures are also constructed efficiently, in the sense that modified instances reuses most of old instance data and unused/unreferenced parts are collected by GC.

                                     

4.5. Features with reference to Java Lazy non-strict evaluation

Evaluation is strict "eager" by default. In other words, Scala evaluates expressions as soon as they are available, rather than as needed. However, it is possible to declare a variable non-strict "lazy" with the lazy keyword, meaning that the code to produce the variables value will not be evaluated until the first time the variable is referenced. Non-strict collections of various types also exist such as the type Stream, a non-strict linked list, and any collection can be made non-strict with the view method. Non-strict collections provide a good semantic fit to things like server-produced data, where the evaluation of the code to generate later elements of a list that in turn triggers a request to a server, possibly located somewhere else on the web only happens when the elements are actually needed.

                                     

4.6. Features with reference to Java Tail recursion

Functional programming languages commonly provide tail call optimization to allow for extensive use of recursion without stack overflow problems. Limitations in Java bytecode complicate tail call optimization on the JVM. In general, a function that calls itself with a tail call can be optimized, but mutually recursive functions cannot. Trampolines have been suggested as a workaround. Trampoline support has been provided by the Scala library with the object scala.util.control.TailCalls since Scala 2.8.0 released 14 July 2010. A function may optionally be annotated with tailrec, in which case it will not compile unless it is tail recursive.

                                     

4.7. Features with reference to Java Case classes and pattern matching

Scala has built-in support for pattern matching, which can be thought of as a more sophisticated, extensible version of a switch statement, where arbitrary data types can be matched rather than just simple types like integers, booleans and strings, including arbitrary nesting. A special type of class known as a case class is provided, which includes automatic support for pattern matching and can be used to model the algebraic data types used in many functional programming languages.

An example of a definition of the quicksort algorithm using pattern matching is this:

The idea here is that we partition a list into the elements less than a pivot and the elements not less, recursively sort each part, and paste the results together with the pivot in between. This uses the same divide-and-conquer strategy of mergesort and other fast sorting algorithms.

The match operator is used to do pattern matching on the object stored in list. Each case expression is tried in turn to see if it will match, and the first match determines the result. In this case, Nil only matches the literal object Nil, but pivot tail matches a non-empty list, and simultaneously destructures the list according to the pattern given. In this case, the associated code will have access to a local variable named pivot holding the head of the list, and another variable tail holding the tail of the list. Note that these variables are read-only, and are semantically very similar to variable bindings established using the let operator in Lisp and Scheme.

Pattern matching also happens in local variable declarations. In this case, the return value of the call to tail.partition is a tuple - in this case, two lists. Pattern matching is the easiest way of fetching the two parts of the tuple.

The form _ < pivot is a declaration of an anonymous function with a placeholder variable; see the section above on anonymous functions.

The list operators which adds an element onto the beginning of a list, similar to cons in Lisp and Scheme and: which appends two lists together, similar to append in Lisp and Scheme both appear. Despite appearances, there is nothing "built-in" about either of these operators. As specified above, any string of symbols can serve as function name, and a method applied to an object can be written "infix"-style without the period or parentheses. The line above as written:

qsortsmaller: pivot qsortrest

could also be written thus:

qsortrest. pivot.:qsortsmaller)

in more standard method-call notation. Methods that end with a colon are right-associative and bind to the object to the right.

                                     

4.8. Features with reference to Java Partial functions

In the pattern-matching example above, the body of the match operator is a partial function, which consists of a series of case expressions, with the first matching expression prevailing, similar to the body of a switch statement. Partial functions are also used in the exception-handling portion of a try statement:

Finally, a partial function can be used alone, and the result of calling it is equivalent to doing a match over it. For example, the prior code for quicksort can be written thus:

Here a read-only variable is declared whose type is a function from lists of integers to lists of integers, and bind it to a partial function. Note that the single parameter of the partial function is never explicitly declared or named. However, we can still call this variable exactly as if it were a normal function:

                                     

4.9. Features with reference to Java Object-oriented extensions

Scala is a pure object-oriented language in the sense that every value is an object. Data types and behaviors of objects are described by classes and traits. Class abstractions are extended by subclassing and by a flexible mixin-based composition mechanism to avoid the problems of multiple inheritance.

Traits are Scalas replacement for Javas interfaces. Interfaces in Java versions under 8 are highly restricted, able only to contain abstract function declarations. This has led to criticism that providing convenience methods in interfaces is awkward the same methods must be reimplemented in every implementation, and extending a published interface in a backwards-compatible way is impossible. Traits are similar to mixin classes in that they have nearly all the power of a regular abstract class, lacking only class parameters Scalas equivalent to Javas constructor parameters, since traits are always mixed in with a class. The super operator behaves specially in traits, allowing traits to be chained using composition in addition to inheritance. The following example is a simple window system:

A variable may be declared thus:

The result of calling mywin.draw is:

In other words, the call to draw first executed the code in TitleDecoration the last trait mixed in, then through the super calls threaded back through the other mixed-in traits and eventually to the code in Window, even though none of the traits inherited from one another. This is similar to the decorator pattern, but is more concise and less error-prone, as it doesnt require explicitly encapsulating the parent window, explicitly forwarding functions whose implementation isnt changed, or relying on run-time initialization of entity relationships. In other languages, a similar effect could be achieved at compile-time with a long linear chain of implementation inheritance, but with the disadvantage compared to Scala that one linear inheritance chain would have to be declared for each possible combination of the mix-ins.

                                     

4.10. Features with reference to Java Expressive type system

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. In particular, the type system supports:

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

Scala is able to infer types by usage. 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.

                                     

4.11. Features with reference to Java Type enrichment

A common technique in Scala, known as "enrich my library" originally termed as "pimp my library" by Martin Odersky in 2006; though concerns were raised about this phrasing due to its negative connotation and immaturity, 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:

Importing the members of MyExtensions brings the implicit conversion to extension class IntPredicates into scope.

                                     

5. Concurrency

Scalas standard library includes support for the actor model, in addition to the standard Java concurrency APIs. Lightbend Inc. provides a platform that includes Akka, a separate open-source framework that provides actor-based concurrency. Akka actors may be distributed or combined with software transactional memory transactors. Alternative communicating sequential processes CSP implementations for channel-based message passing are Communicating Scala Objects, or simply via JCSP.

An Actor is like a thread instance with a mailbox. It can be created by system.actorOf, overriding the receive method to receive messages and using the! exclamation point method to send a message. The following example shows an EchoServer that can receive messages and then print them.

Scala also comes with built-in support for data-parallel programming in the form of Parallel Collections integrated into its Standard Library since version 2.9.0.

The following example shows how to use Parallel Collections to improve performance.

Besides actor support and data-parallelism, Scala also supports asynchronous programming with Futures and Promises, software transactional memory, and event streams.

                                     

6. Cluster computing

The most well-known open-source cluster-computing solution written in Scala is Apache Spark. Additionally, Apache Kafka, the publish–subscribe message queue popular with Spark and other stream processing technologies, is written in Scala.

                                     

7. Testing

There are several ways to test code in Scala. ScalaTest supports multiple testing styles and can integrate with Java-based testing frameworks. ScalaCheck is a library similar to Haskells QuickCheck. specs2 is a library for writing executable software specifications. ScalaMock provides support for testing high-order and curried functions. JUnit and TestNG are popular testing frameworks written in Java.

                                     

8. Comparison with other JVM languages

Scala is often compared with Groovy and Clojure, two other programming languages also using the JVM. Substantial differences between these languages are found in the type system, in the extent to which each language supports object-oriented and functional programming, and in the similarity of their syntax to the syntax of Java.

Scala is statically typed, while both Groovy and Clojure are dynamically typed. This makes the type system more complex and difficult to understand but allows almost all type errors to be caught at compile-time and can result in significantly faster execution. By contrast, dynamic typing requires more testing to ensure program correctness and is generally slower in order to allow greater programming flexibility and simplicity. Regarding speed differences, current versions of Groovy and Clojure allow for optional type annotations to help programs avoid the overhead of dynamic typing in cases where types are practically static. This overhead is further reduced when using recent versions of the JVM, which has been enhanced with an invoke dynamic instruction for methods that are defined with dynamically typed arguments. These advances reduce the speed gap between static and dynamic typing, although a statically typed language, like Scala, is still the preferred choice when execution efficiency is very important.

Regarding programming paradigms, Scala inherits the object-oriented model of Java and extends it in various ways. Groovy, while also strongly object-oriented, is more focused in reducing verbosity. In Clojure, object-oriented programming is deemphasised with functional programming being the main strength of the language. Scala also has many functional programming facilities, including features found in advanced functional languages like Haskell, and tries to be agnostic between the two paradigms, letting the developer choose between the two paradigms or, more frequently, some combination thereof.

Regarding syntax similarity with Java, Scala inherits much of Javas syntax, as is the case with Groovy. Clojure on the other hand follows the Lisp syntax, which is different in both appearance and philosophy. However, learning Scala is also considered difficult because of its many advanced features. This is not the case with Groovy, despite its also being a feature-rich language, mainly because it was designed to be mainly a scripting language.

                                     

9.1. Adoption Language rankings

As of 2013, all JVM-based languages are significantly less popular than the original Java language, which is usually ranked first or second, and which is also simultaneously evolving over time.

The Popularity of Programming Language Index, which tracks searches for language tutorials, ranked Scala 15th in April 2018 with a small downward trend. This makes Scala the most popular JVM-based language after Java, although immediately followed by Kotlin, a JVM-based language with a strong upward trend ranked 16th.

The TIOBE index of programming language popularity employs internet search engine rankings and similar publication-counting to determine language popularity. As of April 2018, it shows Scala in 34th place, having dropped four places over the last two years, but–as mentioned under "Bugs & Change Requests"–TIOBE is aware of issues with its methodology of using search terms which might not be commonly used in some programming language communities. In this ranking Scala is ahead of some functional languages like Haskell 42nd, Erlang, but below other languages like Swift 15th, Perl 16th, Go 19th and Clojure 30th.

The ThoughtWorks Technology Radar, which is an opinion based biannual report of a group of senior technologists, recommended Scala adoption in its languages and frameworks category in 2013. In July 2014, this assessment was made more specific and now refers to a "Scala, the good parts", which is described as "To successfully use Scala, you need to research the language and have a very strong opinion on which parts are right for you, creating your own definition of Scala, the good parts.".

The RedMonk Programming Language Rankings, which establishes rankings based on the number of GitHub projects and questions asked on Stack Overflow, ranks Scala 14th. Here, Scala is placed inside a second-tier group of languages–ahead of Go, PowerShell and Haskell, and behind Swift, Objective-C, Typescript and R. However, in its 2018 report, the Rankings noted a drop of Scalas rank for the third time in a row, questioning "how much of the available oxygen for Scala is consumed by Kotlin as the latter continues to rocket up these rankings".

In the 2018 edition of the "State of Java" survey, which collected data from 5160 developers on various Java-related topics, Scala places third in terms of usage of alternative languages on the JVM. Compared to the last years edition of the survey, Scalas usage among alternative JVM languages fell by almost a quarter from 28.4% to 21.5%, overtaken by Kotlin, which rose from 11.4% in 2017 to 28.8% in 2018.

                                     

9.2. Adoption Companies

  • Zalando moved its technology stack from Java to Scala and Play.
  • Swiss bank UBS approved Scala for general production usage.
  • Coursera uses Scala and Play Framework.
  • Morgan Stanley uses Scala extensively in their finance and asset-related projects.
  • Foursquare uses Scala and Lift.
  • Gilt uses Scala and Play Framework.
  • The Guardian newspapers high-traffic website guardian.co.uk announced in April 2011 that it was switching from Java to Scala,
  • Airbnb develops open-source machine-learning software "Aerosolve", written in Java and Scala.
  • In April 2009, Twitter announced that it had switched large portions of its backend from Ruby to Scala and intended to convert the rest.
  • Duolingo uses Scala for their back-end module that generates lessons.
  • Databricks uses Scala for the Apache Spark Big Data platform.
  • Walmart Canada Uses Scala for their back-end platform.
  • HMRC uses Scala for many UK Government Tax applications.
  • LinkedIn uses the Scalatra microframework to power its Signal API.
  • Verizon seeking to make "a next-generation framework" using Scala.
  • Meetup uses Unfiltered toolkit for real-time APIs.
  • SoundCloud uses Scala for its back-end, employing technologies such as Finagle micro services, Scalding and Spark data processing.
  • The New York Times revealed in 2014 that its internal content management system Blackbeard is built using Scala, Akka and Play.
  • Remember the Milk uses Unfiltered toolkit, Scala and Akka for public API and real-time updates.
  • There are teams within Google/Alphabet Inc. that use Scala, mostly due to acquisitions such as Firebase and Nest.
  • Apple Inc. uses Scala in certain teams, along with Java and the Play framework.
  • The Huffington Post newspaper started to employ Scala as part of its contents delivery system Athena in 2013.
                                     

10. Criticism

In March 2015, former VP of the Platform Engineering group at Twitter Raffi Krikorian, stated that he would not have chosen Scala in 2011 due to its learning curve. The same month, LinkedIn SVP Kevin Scott stated their decision to "minimize dependence on Scala". In November 2011, Yammer moved away from Scala for reasons that included the learning curve for new team members and incompatibility from one version of the Scala compiler to the next.

                                     
  • Go, also known as Golang, is a statically typed, compiled programming language designed at Google by Robert Griesemer, Rob Pike, and Ken Thompson. Go is
  • of programming languages spans from documentation of early mechanical computers to modern tools for software development. Early programming languages were
  • ND4S is a free, open - source extension of the Scala programming language operating on the Java Virtual Machine though it is compatible with both Java
  • and its approach is based on, the programming language Scala where users begin with a simple subset of the language and progress in steps. Its graphical
  • Fortress is a discontinued experimental programming language for high - performance computing, created by Sun Microsystems with funding from DARPA s High
  • lists concurrent and parallel programming languages categorizing them by a defining paradigm. A concurrent programming language is defined as one which uses
  • Java is a general - purpose programming language that is class - based, object - oriented, and designed to have as few implementation dependencies as possible
  • open - source build tool for Scala and Java projects, similar to Java s Maven and Ant. Its main features are: Native support for compiling Scala code and integrating
  • An interpreted language is a type of programming language for which most of its implementations execute instructions directly and freely, without previously

Users also searched:

scala vs python,

...
...
...