After an internal release in late 2003, Scala was released publicly in early 2004 on the Java platform,[14][8][13][15] A second version (v2.0) followed in March 2006.[8]

Although Scala had extensive support for functional programming from its inception, Java remained a mostly object-oriented language until the inclusion of lambda expressions with Java 8 in 2014.

On 17 January 2011, the Scala team won a five-year research grant of over €2.3 million from the European Research Council.[16] 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.[17][18][19][20]

Scala runs on the Java platform (Java virtual machine) and is compatible with existing Java programs.[14] 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, Scala's Java compatibility makes it well-suited to Android development, more so when a functional approach is preferred.[21]

The reference Scala software distribution, including compiler and libraries, is released under a BSD license.[22]

Scala.js is a Scala compiler that compiles to JavaScript, making it possible to write Scala programs that can run in web browsers.[23]

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.[24][25]

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, Scala's 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:

println("Hello, World!")

Scala includes interactive shell and scripting support.[27] 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:

Array references are written like function calls, e.g. array(i) rather than array[i]. (Internally in Scala, both arrays and functions are conceptualized as kinds of mathematical mappings from one object to another.)

Generic types are written as e.g. List[String] rather than Java's List<String>.

Instead of the pseudo-type void, Scala has the actual singleton classUnit (see below).

The code above shows some of the conceptual differences between Java and Scala's handling of classes:

Scala has no static variables or methods. Instead, it has singleton objects, which are essentially classes with only one object in the class. 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.[14] (The underlying class for the singleton object has a $ appended. Hence, for class Foo with companion object object Foo, under the hood there's a class Foo$ containing the companion object's code, and one object of this class is created, using the singleton pattern.)

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 it's 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 the same compiling model as Java and C#, namely separate compiling and dynamic class loading, so that Scala code can call Java libraries.

Scala's operational characteristics are the same as Java's, the Scala compiler generates byte code that is nearly identical to that generated by the Java compiler.[14] 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.[28]

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:

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

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.

Any method can be used as an infix operator, e.g. "%d apples".format(num) 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.

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.update(42). Similarly, foo(42) is short for foo.apply(42), and foo(4) = 2 is short for foo.update(4, 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.

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).

Class body variables can be transparently implemented as separate getter and setter methods. For trait FooLike { var bar: Int }, an implementation may be objectFooextendsFooLike{privatevarx=0;defbar=x;defbar_=(value:Int){x=value}}}}. The call site will still be able to use a concise foo.bar = 42.

The use of curly braces instead of parentheses is allowed in method calls. This allows pure library implementations of new control structures,[29] 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.fill(4) { math.random } is the same as Vector.fill(4)(math.random). The curly braces variant allows the expression to span multiple lines.

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, Erlang's 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.

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.

Instead of the Java "foreach" loops for looping through an iterator, Scala has a much more powerful concept of for-expressions. These 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.

(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[30] that allows new methods to be added to existing types.)

A more complex example of iterating over a map is:

// Given a map specifying Twitter users mentioned in a set of tweets,// and number of times each user was mentioned, look up the users// in a map of known politicians, and return a new map giving only the// Democratic politicians (as objects, rather than strings).valdem_mentions=for{(mention,times)<-mentionsaccount<-accounts.get(mention)ifaccount.party=="Democratic"}yield(account,times)

Expression (mention, times) <- mentions is an example of pattern matching (see below). Iterating over a map returns a set of key-value tuples, and pattern-matching allows the tuples to easily be destructured into separate variables for the key and value. Similarly, the result of the comprehension also returns key-value tuples, which are automatically built back up into a map because the source object (from the variable mentions) is a map. Note that if mentions instead held a list, set, array or other collection of tuples, exactly the same code above would yield a new collection of the same type.

While supporting all of the object-oriented features available in Java (and in fact, augmenting them in various ways), Scala also provides a large number of capabilities that are normally found only in functional programming languages. Together, these features allow Scala programs to be written in an almost completely functional style and also allow functional and object-oriented styles to be mixed.

Unlike C or Java, but similar to languages such as Lisp, Scala makes no distinction between statements and expressions. All statements are in fact expressions that evaluate to some value. Functions that would be declared as returning void in C or Java, and statements like while that logically do not return a value, are in Scala considered to return the type Unit, which is a singleton type, with only one object of that type. Functions and operators that never return at all (e.g. the throw operator or a function that always exits non-locally using an exception) logically have return type Nothing, a special type containing no objects; that is, a bottom type, i.e. a subclass of every possible type. (This in turn makes type Nothing compatible with every type, allowing type inference to function correctly.)

Similarly, an if-then-else "statement" is actually an expression, which produces a value, i.e. the result of evaluating one of the two branches. This means that such a block of code can be inserted wherever an expression is desired, obviating the need for a ternary operator in Scala:

// Java:inthexDigit=x>=10?x+'A'-10:x+'0';

// Scala:valhexDigit=if(x>=10)x+'A'-10elsex+'0'

For similar reasons, return statements are unnecessary in Scala, and in fact are discouraged. As in Lisp, the last expression in a block of code is the value of that block of code, and if the block of code is the body of a function, it will be returned by the function.

To make it clear that all expressions are functions, even methods that return Unit are written with an equals sign

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

or equivalently (with type inference, and omitting the unnecessary braces):

Due to type inference, the type of variables, function return values, and many other expressions can typically be omitted, as the compiler can deduce it. Examples are val x = "foo" (for an immutable, constant variable or immutable object) or var x = 1.5 (for a variable whose value can later be changed). Type inference in Scala is essentially local, in contrast to the more global Hindley-Milner algorithm used in Haskell, ML and other more purely functional languages. This is done to facilitate object-oriented programming, the result is that certain types still need to be declared (most notably, function parameters, and the return types of recursive functions), e.g.

In Scala, functions are objects, and a convenient syntax exists for specifying anonymous functions. An example is the expression x => 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 Java's 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:

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 member(s); 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.[31]

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 variable's 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.

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.[32] 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.[33]

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. (From the perspective of Scala, a case class is simply a normal class for which the compiler automatically adds certain behaviors that could also be provided manually, e.g., definitions of methods providing for deep comparisons and hashing, and destructuring a case class on its constructor parameters during pattern matching.)

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. (Tuples differ from other types of containers, e.g. lists, in that they are always of fixed size and the elements can be of differing types — although here they are both the same.) 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:

qsort(smaller) ::: pivot :: qsort(rest)

could also be written thus:

qsort(rest).::(pivot).:::(qsort(smaller))

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

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:

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:

Traits are Scala's replacement for Java's 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 (Scala's equivalent to Java's 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:

abstractclassWindow{// abstractdefdraw()}classSimpleWindowextendsWindow{defdraw(){println("in SimpleWindow")// draw a basic window}}traitWindowDecorationextendsWindow{}traitHorizontalScrollbarDecorationextendsWindowDecoration{// "abstract override" is needed here in order for "super()" to work because the parent// function is abstract. If it were concrete, regular "override" would be enough.abstractoverridedefdraw(){println("in HorizontalScrollbarDecoration")super.draw()// now draw a horizontal scrollbar}}traitVerticalScrollbarDecorationextendsWindowDecoration{abstractoverridedefdraw(){println("in VerticalScrollbarDecoration")super.draw()// now draw a vertical scrollbar}}traitTitleDecorationextendsWindowDecoration{abstractoverridedefdraw(){println("in TitleDecoration")super.draw()// now draw the title bar}}

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 doesn't require explicitly encapsulating the parent window, explicitly forwarding functions whose implementation isn't 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.

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

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.

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

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.[42] The following example shows an EchoServer that can receive messages and then print them.

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

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[34] 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 Java's 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.[citation needed]

As of 2013[update], all JVM-based languages (Clojure, Groovy, Kotlin, Scala) are significantly less popular than the original Java language, which is usually ranked first or second,[91][92] and which is also simultaneously evolving over time.

The Popularity of Programming Language Index,[93] 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[92] 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 half-yearly report of a group of senior technologists,[94] recommended Scala adoption in its languages and frameworks category in 2013;[95] 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."[96].

The RedMonk Programming Language Rankings, which establishes rankings based on the number of GitHub projects and questions asked on Stack Overflow, ranks Scala 14th.[91] 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 Scala's 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"[91].

In the 2018 edition of the "State of Java" survey[97], 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 year's edition of the survey, Scala's 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.

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,[123] the same month, LinkedIn SVP Kevin Scott stated their decision to "minimize [their] dependence on Scala".[124] 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.[125]

^"Home". Blog.lostlake.org. Archived from the original on 31 August 2010. Retrieved 2013-06-25.

^Scala's built-in control structures such as if or while cannot be re-implemented. There is a research project, Scala-Virtualized, that aimed at removing these restrictions: Adriaan Moors, Tiark Rompf, Philipp Haller and Martin Odersky. Scala-Virtualized. Proceedings of the ACM SIGPLAN 2012 workshop on Partial evaluation and program manipulation, 117–120. July 2012.

^Implicit classes were introduced in Scala 2.10 to make method extensions more concise. This is equivalent to adding a method implicit def IntPredicate(i: Int) = new IntPredicate(i). The class can also be defined as implicit class IntPredicates(val i: Int) extends AnyVal { ... }, producing a so-called value class, also introduced in Scala 2.10. The compiler will then eliminate actual instantiations and generate static methods instead, allowing extension methods to have virtually no performance overhead.

1.
Programming paradigm
–
Programming paradigms are a way to classify programming languages based on the features of various programming languages. Other paradigms are concerned mainly with the way that code is organized, yet others are concerned mainly with the style of syntax and grammar. The communication between the units of code is not explicit, meanwhile, in object-oriented programming, code is organized into objects that contain state that is only modified by the code that is part of the object. Most object-oriented languages are also imperative languages, in contrast, languages that fit the declarative paradigm do not state the order in which to execute operations. Instead, they supply a number of operations that are available in the system, the implementation of the languages execution model tracks which operations are free to execute and chooses the order on its own. More at Comparison of multi-paradigm programming languages, just as software engineering is defined by differing methodologies, so the programming languages are defined by differing paradigms. Some languages are designed to support one paradigm, while other programming languages support multiple paradigms, for example, programs written in C++, Object Pascal or PHP can be purely procedural, purely object-oriented, or can contain elements of both or other paradigms. Software designers and programmers decide how to use those paradigm elements, in object-oriented programming, programs are treated as a set of interacting objects. In functional programming, programs are treated as a sequence of function evaluations. When programming computers or systems with many processors, in process-oriented programming, many programming paradigms are as well known for the techniques they forbid as for those they enable. For instance, pure functional programming disallows use of side-effects, while structured programming disallows use of the goto statement, partly for this reason, new paradigms are often regarded as doctrinaire or overly rigid by those accustomed to earlier styles. Yet, avoiding certain techniques can make it easier to understand program behavior, programming paradigms can also be compared with programming models which allow invoking an external execution model by using only an API. Programming models can also be classified into paradigms, based on features of the execution model, for parallel computing, using a programming model instead of a language is common. The reason is that details of the parallel hardware leak into the used to program the hardware. This causes the programmer to have to map patterns in the algorithm onto patterns in the execution model, as a consequence, no one parallel programming language maps well to all computation problems. It is thus convenient to use a base sequential language and insert API calls to parallel execution models. These can be considered flavors of programming paradigm that apply to only parallel languages, different approaches to programming have developed over time, being identified as such either at the time or retrospectively. An early approach consciously identified as such is structured programming, advocated since the mid 1960s and these are sometimes called first- and second-generation languages

2.
Martin Odersky
–
Martin Odersky is a German computer scientist and professor of programming methods at École Polytechnique Fédérale de Lausanne in Switzerland. He specializes in code analysis and programming languages and he designed the Scala programming language and Generic Java both with others. He implemented the GJ compiler, and his became the basis of javac. In 2007, he was inducted as a Fellow of the Association for Computing Machinery, in 1989, he received his Ph. D. from ETH Zurich under the supervision of Niklaus Wirth, who is best known as the designer of several programming languages, including Pascal. He did postdoctoral work at IBM and Yale University, on 12 May 2011, Odersky and collaborators launched Typesafe Inc. a company to provide commercial support, training, and services for Scala, and he currently serves as the chairman and chief architect. He teaches two courses on the open online course provider, Coursera, namely Functional Programming Principles in Scala

3.
Software developer
–
A software developer is a person concerned with facets of the software development process, including the research, design, programming, and testing of computer software. Other job titles which are used with similar meanings are programmer, software analyst. According to developer Eric Sink, the differences between system design, software development, and programming are more apparent, even more so that developers become systems architects, those who design the multi-leveled architecture or component interactions of a large software system. In a large company, there may be employees whose sole responsibility consists of one of the phases above. In smaller development environments, a few people or even an individual might handle the complete process. The word software was coined as a prank as early as 1953, before this time, computers were programmed either by customers, or the few commercial computer vendors of the time, such as UNIVAC and IBM. The first company founded to provide products and services was Computer Usage Company in 1955. The software industry expanded in the early 1960s, almost immediately after computers were first sold in mass-produced quantities, universities, government, and business customers created a demand for software. Many of these programs were written in-house by full-time staff programmers, some were distributed freely between users of a particular machine for no charge. Others were done on a basis, and other firms such as Computer Sciences Corporation started to grow. The computer/hardware makers started bundling operating systems, systems software and programming environments with their machines, new software was built for microcomputers, so other manufacturers including IBM, followed DECs example quickly, resulting in the IBM AS/400 amongst others. The industry expanded greatly with the rise of the computer in the mid-1970s. In the following years, it created a growing market for games, applications. DOS, Microsofts first operating system product, was the dominant operating system at the time, by 2014 the role of cloud developer had been defined, in this context, one definition of a developer in general was published, Developers make software for the world to use. The job of a developer is to crank out code -- fresh code for new products, code fixes for maintenance, code for business logic, bus factor Software Developer description from the US Department of Labor

4.
Software release life cycle
–
Usage of the alpha/beta test terminology originated at IBM. As long ago as the 1950s, IBM used similar terminology for their hardware development, a test was the verification of a new product before public announcement. B test was the verification before releasing the product to be manufactured, C test was the final test before general availability of the product. Martin Belsky, a manager on some of IBMs earlier software projects claimed to have invented the terminology, IBM dropped the alpha/beta terminology during the 1960s, but by then it had received fairly wide notice. The usage of beta test to refer to testing done by customers was not done in IBM, rather, IBM used the term field test. Pre-alpha refers to all activities performed during the project before formal testing. These activities can include requirements analysis, software design, software development, in typical open source development, there are several types of pre-alpha versions. Milestone versions include specific sets of functions and are released as soon as the functionality is complete, the alpha phase of the release life cycle is the first phase to begin software testing. In this phase, developers generally test the software using white-box techniques, additional validation is then performed using black-box or gray-box techniques, by another testing team. Moving to black-box testing inside the organization is known as alpha release, alpha software can be unstable and could cause crashes or data loss. Alpha software may not contain all of the features that are planned for the final version, in general, external availability of alpha software is uncommon in proprietary software, while open source software often has publicly available alpha versions. The alpha phase usually ends with a freeze, indicating that no more features will be added to the software. At this time, the software is said to be feature complete, Beta, named after the second letter of the Greek alphabet, is the software development phase following alpha. Software in the stage is also known as betaware. Beta phase generally begins when the software is complete but likely to contain a number of known or unknown bugs. Software in the phase will generally have many more bugs in it than completed software, as well as speed/performance issues. The focus of beta testing is reducing impacts to users, often incorporating usability testing, the process of delivering a beta version to the users is called beta release and this is typically the first time that the software is available outside of the organization that developed it. Beta version software is useful for demonstrations and previews within an organization

5.
Computing platform
–
Computing platform means in general sense, where any piece of software is executed. It may be the hardware or the system, even a web browser or other application. The term computing platform can refer to different abstraction levels, including a hardware architecture, an operating system. In total it can be said to be the stage on which programs can run. For example, an OS may be a platform that abstracts the underlying differences in hardware, platforms may also include, Hardware alone, in the case of small embedded systems. Embedded systems can access hardware directly, without an OS, this is referred to as running on bare metal, a browser in the case of web-based software. The browser itself runs on a platform, but this is not relevant to software running within the browser. An application, such as a spreadsheet or word processor, which hosts software written in a scripting language. This can be extended to writing fully-fledged applications with the Microsoft Office suite as a platform, software frameworks that provide ready-made functionality. Cloud computing and Platform as a Service, the social networking sites Twitter and facebook are also considered development platforms. A virtual machine such as the Java virtual machine, applications are compiled into a format similar to machine code, known as bytecode, which is then executed by the VM. A virtualized version of a system, including virtualized hardware, OS, software. These allow, for instance, a typical Windows program to run on what is physically a Mac, some architectures have multiple layers, with each layer acting as a platform to the one above it. In general, a component only has to be adapted to the layer immediately beneath it, however, the JVM, the layer beneath the application, does have to be built separately for each OS

6.
Java virtual machine
–
A Java virtual machine is an abstract computing machine that enables a computer to run a Java program. There are three notions of the JVM, specification, implementation, and instance, the specification is a document that formally describes what is required of a JVM implementation. Having a single specification ensures all implementations are interoperable, a JVM implementation is a computer program that meets the requirements of the JVM specification. An instance of a JVM is a running in a process that executes a computer program compiled into Java bytecode. Java Runtime Environment is a package that contains what is required to run a Java program. It includes a Java Virtual Machine implementation together with an implementation of the Java Class Library, the Oracle Corporation, which owns the Java trademark, distributes a Java Runtime environment with their Java Virtual Machine called HotSpot. Java Development Kit is a superset of a JRE and contains tools for Java programmers, the Java Development Kit is provided free of charge either by Oracle Corporation directly, or by the OpenJDK open source project, which is governed by Oracle. The Java virtual machine is an abstract computer defined by a specification, the main reason for this omission is to not unnecessarily constrain implementers. Any Java application can be run only inside some concrete implementation of the specification of the Java virtual machine. Starting with Java Platform, Standard Edition 5.0, changes to the JVM specification have been developed under the Java Community Process as JSR924. As of 2006, changes to specification to support changes proposed to the file format are being done as a maintenance release of JSR924. Oracle provides tests that verify the operation of implementations of the Java Virtual Machine. One of Oracles JVMs is named HotSpot, the other, inherited from BEA Systems is JRockit, clean-room Java implementations include Kaffe and IBM J9. Oracle owns the Java trademark and may allow its use to certify implementation suites as fully compatible with Oracles specification, one of the organizational units of JVM byte code is a class. A class loader implementation must be able to recognize and load anything that conforms to the Java class file format, any implementation is free to recognize other binary forms besides class files, but it must recognize class files. Initialization, invokes Java code that initializes class variables to their proper starting values, in general, there are two types of class loader, bootstrap class loader and user defined class loader. Every Java virtual machine implementation must have a class loader. The Java virtual machine specification doesnt specify how a class loader should locate classes, the JVM has instructions for the following groups of tasks, The aim is binary compatibility

7.
JavaScript
–
JavaScript is a high-level, dynamic, untyped, and interpreted programming language. It has been standardized in the ECMAScript language specification, JavaScript is prototype-based with first-class functions, making it a multi-paradigm language, supporting object-oriented, imperative, and functional programming styles. JavaScript was influenced by programming languages such as Self and Scheme, JavaScript is also used in environments that are not Web-based, such as PDF documents, site-specific browsers, and desktop widgets. Newer and faster JavaScript virtual machines and platforms built upon them have increased the popularity of JavaScript for server-side Web applications. On the client side, developers have traditionally implemented JavaScript as an interpreted language, programmers also use JavaScript in video-game development, in crafting desktop and mobile applications, and in server-side network programming with run-time environments such as Node. js. In 1994, a company called Mosaic Communications was founded in Mountain View, California, however, it intentionally shared no code with NCSA Mosaic. The internal codename for the browser was Mozilla, which stood for Mosaic killer. The first version of the Web browser, Mosaic Netscape 0.9, was released in late 1994, within four months it had already taken three-quarters of the browser market and became the main browser for Internet in the 1990s. To avoid trademark problems with the NCSA, the browser was subsequently renamed Netscape Navigator in the same year. Netscape Communications realized that the Web needed to more dynamic. In 1995, the company recruited Brendan Eich with the goal of embedding the Scheme programming language into its Netscape Navigator, to defend the idea of JavaScript against competing proposals, the company needed a prototype. Eich wrote one in 10 days, in May 1995, there is a common misconception that JavaScript was influenced by an earlier Web page scripting language developed by Nombas named C--. Brendan Eich, however, had never heard of C-- before he created LiveScript, Nombas did pitch their embedded Web page scripting to Netscape, though Web page scripting was not a new concept, as shown by the ViolaWWW Web browser. Nombas later switched to offering JavaScript instead of C-- in their ScriptEase product and was part of the TC39 group that standardized ECMAScript, in December 1995, soon after releasing JavaScript for browsers, Netscape introduced an implementation of the language for server-side scripting with Netscape Enterprise Server. Since the mid-2000s, additional server-side JavaScript implementations have been introduced, Microsoft script technologies including VBScript and JScript were released in 1996. JScript, an implementation of Netscapes JavaScript, was part of Internet Explorer 3. JScript was also available for server-side scripting in Internet Information Server, JavaScript began to acquire a reputation for being one of the roadblocks to a cross-platform and standards-driven Web. Some developers took on the task of trying to make their sites work in both major browsers, but many could not afford the time

8.
LLVM
–
The LLVM compiler infrastructure project is a collection of modular and reusable compiler and toolchain technologies used to develop compiler front ends and back ends. LLVM is written in C++ and is designed for compile-time, link-time, run-time, the LLVM project started in 2000 at the University of Illinois at Urbana–Champaign, under the direction of Vikram Adve and Chris Lattner. LLVM was originally developed as an infrastructure to investigate dynamic compilation techniques for static and dynamic programming languages. LLVM was released under the University of Illinois/NCSA Open Source License, in 2005, Apple Inc. hired Lattner and formed a team to work on the LLVM system for various uses within Apples development systems. LLVM is an part of Apples latest development tools for macOS and iOS. Since 2013, Sony has been using LLVMs primary front end Clang compiler in the development kit of its PS4 console. Now, LLVM is a brand that applies to the LLVM umbrella project, the LLVM intermediate representation, the LLVM debugger, LLVM is administered by the LLVM Foundation. Its president is compiler engineer Tanya Lattner, the Association for Computing Machinery presented Adve, Lattner, and Evan Cheng with the 2012 ACM Software System Award for LLVM. LLVM can provide the middle layers of a compiler system, taking intermediate representation code from a compiler. This new IR can then be converted and linked into machine-dependent assembly language code for a target platform, LLVM can accept the IR from the GNU Compiler Collection toolchain, allowing it to be used with a wide array of extant compilers written for that project. LLVM can also generate relocatable machine code at compile-time or link-time or even binary machine code at run-time, LLVM supports a language-independent instruction set and type system. Each instruction is in static single assignment form, meaning that each variable is assigned once and this helps simplify the analysis of dependencies among variables. LLVM allows code to be compiled statically, as it is under the traditional GCC system, or left for late-compiling from the IR to machine code via just-in-time compilation, similar to Java. The type system consists of basic types such as integer or floating point numbers and five derived types, pointers, arrays, vectors, structures, a type construct in a concrete language can be represented by combining these basic types in LLVM. For example, a class in C++ can be represented by a mix of structures, functions and this feature is used in the OpenGL pipeline of Mac OS X Leopard to provide support for missing hardware features. Graphics code within the OpenGL stack can be left in intermediate representation, on systems with high-end graphics processing units, the resulting code remains quite thin, passing the instructions on to the GPU with minimal changes. On systems with low-end GPUs, LLVM will compile optional procedures that run on the central processing unit that emulate instructions that the GPU cannot run internally. LLVM improved performance on machines using Intel GMA chipsets

9.
Software license
–
A software license is a legal instrument governing the use or redistribution of software. Under United States copyright law all software is copyright protected, in code as also object code form. The only exception is software in the public domain, most distributed software can be categorized according to its license type. Two common categories for software under copyright law, and therefore with licenses which grant the licensee specific rights, are proprietary software and free, unlicensed software outside the copyright protection is either public domain software or software which is non-distributed, non-licensed and handled as internal business trade secret. Contrary to popular belief, distributed unlicensed software is copyright protected. Examples for this are unauthorized software leaks or software projects which are placed on public software repositories like GitHub without specified license. As voluntarily handing software into the domain is problematic in some international law domains, there are also licenses granting PD-like rights. Therefore, the owner of a copy of software is legally entitled to use that copy of software. Hence, if the end-user of software is the owner of the respective copy, as many proprietary licenses only enumerate the rights that the user already has under 17 U. S. C. §117, and yet proclaim to take away from the user. Proprietary software licenses often proclaim to give software publishers more control over the way their software is used by keeping ownership of each copy of software with the software publisher. The form of the relationship if it is a lease or a purchase, for example UMG v. Augusto or Vernor v. Autodesk. The ownership of goods, like software applications and video games, is challenged by licensed. The Swiss based company UsedSoft innovated the resale of business software and this feature of proprietary software licenses means that certain rights regarding the software are reserved by the software publisher. Therefore, it is typical of EULAs to include terms which define the uses of the software, the most significant effect of this form of licensing is that, if ownership of the software remains with the software publisher, then the end-user must accept the software license. In other words, without acceptance of the license, the end-user may not use the software at all, one example of such a proprietary software license is the license for Microsoft Windows. The most common licensing models are per single user or per user in the appropriate volume discount level, Licensing per concurrent/floating user also occurs, where all users in a network have access to the program, but only a specific number at the same time. Another license model is licensing per dongle which allows the owner of the dongle to use the program on any computer, Licensing per server, CPU or points, regardless the number of users, is common practice as well as site or company licenses

10.
Erlang (programming language)
–
Erlang is a general-purpose, concurrent, functional programming language, as well as a garbage-collected runtime system. It was originally a proprietary language within Ericsson, developed by Joe Armstrong, Robert Virding and Mike Williams in 1986, Erlang/OTP is supported and maintained by the OTP product unit at Ericsson. Erlang was designed with the aim of improving the development of telephony applications, the initial version of Erlang was implemented in Prolog and was influenced by the programming language PLEX used in earlier Ericsson exchanges. By 1988 Erlang had proven that it was suitable for prototyping telephone exchanges, one group within Ericsson estimated that it would need to be 40 times faster in order to be suitable for production use. In 1992 work began on the BEAM virtual machine which compiles Erlang to C using a mix of natively compiled code, according to Armstrong, the language went from lab product to real applications following the collapse of the next-generation AXE exchange named AXE-N in 1995. As a result, Erlang was chosen for the next ATM exchange AXD, in 1998 Ericsson announced the AXD301 switch, containing over a million lines of Erlang and reported to achieve a high availability of nine 9s. Shortly thereafter, Ericsson Radio Systems banned the use of Erlang for new products. The ban caused Armstrong and others to leave Ericsson, the implementation was open-sourced at the end of the year. Ericsson eventually lifted the ban, it re-hired Armstrong in 2004, in 2006, native symmetric multiprocessing support was added to the runtime system and virtual machine. The Erlang view of the world, as Joe Armstrong, co-inventor of Erlang summarized in his PhD thesis, process creation and destruction is a lightweight operation. Message passing is the way for processes to interact. If you know the name of a process you can send it a message, processes do what they are supposed to do or fail. Joe Armstrong pointed out in an interview with Rackspace in 2013, “If Java is write once, run anywhere, then Erlang is write once, run forever. ”Erlang has now adopted by companies worldwide, including Nortel. Erlang is used in Ericsson’s support nodes, and in GPRS, 3G, the expression is a list comprehension, meaning Construct a list of elements Front such that Front is a member of Rest, and Front is less than Pivot. ++ is the list concatenation operator. A comparison function can be used for complicated structures for the sake of readability. The following code would sort lists according to length, Here again, a Pivot is taken from the first parameter given to qsort and the rest of Lists is named Rest. It is not named in the first definition of qsort, which deals with the case of an empty list and thus has no need of this function. Erlang has eight primitive data types, Integers Integers are written as sequences of digits, for example,12,12375

11.
Haskell (programming language)
–
Haskell /ˈhæskəl/ is a standardized, general-purpose purely functional programming language, with non-strict semantics and strong static typing. It is named after logician Haskell Curry, the latest standard of Haskell is Haskell 2010. As of May 2016, a group is working on the next version, Haskell features a type system with type inference and lazy evaluation. Type classes first appeared in the Haskell programming language and its main implementation is the Glasgow Haskell Compiler. Haskell is based on the semantics, but not the syntax, of the language Miranda, Haskell is used widely in academia and also used in industry. Following the release of Miranda by Research Software Ltd, in 1985, by 1987, more than a dozen non-strict, purely functional programming languages existed. Of these, Miranda was used most widely, but it was proprietary software, the committees purpose was to consolidate the existing functional languages into a common one that would serve as a basis for future research in functional-language design. The first version of Haskell was defined in 1990, the committees efforts resulted in a series of language definitions. The committee expressly welcomed creating extensions and variants of Haskell 98 via adding and incorporating experimental features, in February 1999, the Haskell 98 language standard was originally published as The Haskell 98 Report. In January 2003, a version was published as Haskell 98 Language and Libraries. The language continues to rapidly, with the Glasgow Haskell Compiler implementation representing the current de facto standard. In early 2006, the process of defining a successor to the Haskell 98 standard, informally named Haskell Prime and this was intended to be an ongoing incremental process to revise the language definition, producing a new revision up to once per year. The first revision, named Haskell 2010, was announced in November 2009 and it introduces the Language-Pragma-Syntax-Extension which allows for code designating a Haskell source as Haskell 2010 or requiring certain extensions to the Haskell language. Haskell features lazy evaluation, pattern matching, list comprehension, type classes and it is a purely functional language, which means that in general, functions in Haskell have no side effects. A distinct construct exists to represent side effects, orthogonal to the type of functions, a pure function may return a side effect which is subsequently executed, modeling the impure functions of other languages. Haskell has a strong, static type system based on Hindley–Milner type inference, haskells principal innovation in this area is to add type classes, originally conceived as a principled way to add overloading to the language, but since finding many more uses. The construct which represents side effects is an example of a monad, monads are a general framework which can model different kinds of computation, including error handling, nondeterminism, parsing, and software transactional memory. Monads are defined as ordinary datatypes, but Haskell provides some syntactic sugar for their use, Haskell has an open, published specification, and multiple implementations exist

12.
Lisp (programming language)
–
Lisp is a family of computer programming languages with a long history and a distinctive, fully parenthesized prefix notation. Originally specified in 1958, Lisp is the second-oldest high-level programming language in use today. Only Fortran is older, by one year, Lisp has changed since its early days, and many dialects have existed over its history. Today, the best known general-purpose Lisp dialects are Common Lisp, Lisp was originally created as a practical mathematical notation for computer programs, influenced by the notation of Alonzo Churchs lambda calculus. It quickly became the programming language for artificial intelligence research. The name LISP derives from LISt Processor, linked lists are one of Lisps major data structures, and Lisp source code is made of lists. Thus, Lisp programs can manipulate source code as a data structure, the interchangeability of code and data gives Lisp its instantly recognizable syntax. All program code is written as s-expressions, or parenthesized lists, Lisp was invented by John McCarthy in 1958 while he was at the Massachusetts Institute of Technology. McCarthy published its design in a paper in Communications of the ACM in 1960, entitled Recursive Functions of Symbolic Expressions and Their Computation by Machine and he showed that with a few simple operators and a notation for functions, one can build a Turing-complete language for algorithms. Information Processing Language was the first AI language, from 1955 or 1956, and already included many of the concepts, such as list-processing and recursion, McCarthys original notation used bracketed M-expressions that would be translated into S-expressions. As an example, the M-expression car is equivalent to the S-expression, once Lisp was implemented, programmers rapidly chose to use S-expressions, and M-expressions were abandoned. M-expressions surfaced again with short-lived attempts of MLISP by Horace Enea, Lisp was first implemented by Steve Russell on an IBM704 computer. Russell had read McCarthys paper and realized that the Lisp eval function could be implemented in machine code, the result was a working Lisp interpreter which could be used to run Lisp programs, or more properly, evaluate Lisp expressions. Two assembly language macros for the IBM704 became the operations for decomposing lists, car. From the context, it is clear that the register is used here to mean memory register. Lisp dialects still use car and cdr for the operations that return the first item in a list, the first complete Lisp compiler, written in Lisp, was implemented in 1962 by Tim Hart and Mike Levin at MIT. This compiler introduced the Lisp model of incremental compilation, in which compiled and interpreted functions can intermix freely, the language used in Hart and Levins memo is much closer to modern Lisp style than McCarthys earlier code. Lisp was a system to implement with the compiler techniques

13.
OCaml
–
A member of the ML language family, OCaml extends the core Caml language with object-oriented programming constructs. OCamls toolset includes an interactive top-level interpreter, a compiler, a reversible debugger, a package manager. OCaml is the successor to Caml Light, the acronym CAML originally stood for Categorical Abstract Machine Language, although OCaml omits this abstract machine. OCaml is a free and open-source software project managed and principally maintained by French Institute for Research in Computer Science, in the early 2000s, many new languages adopted elements from OCaml, most notably F# and Scala. ML-derived languages are best known for their type systems and type-inferring compilers. OCaml unifies functional, imperative, and object-oriented programming under an ML-like type system, thus, programmers need not be highly familiar with the pure functional language paradigm to use OCaml. OCamls static type system can help eliminate problems at runtime, however, it also forces the programmer to conform to the constraints of the type system, which can require careful thought and close attention. A type-inferring compiler greatly reduces the need for manual type annotations, for example, the data type of variables and the signature of functions usually need not be declared explicitly, as they do in Java. Nonetheless, effective use of OCamls type system can require some sophistication on the part of a programmer, OCaml is perhaps most distinguished from other languages with origins in academia, by its emphasis on performance. These are rare enough that avoiding them is possible in practice. Aside from type-checking overhead, functional programming languages are, in general, challenging to compile to efficient machine language code, xavier Leroy has stated that OCaml delivers at least 50% of the performance of a decent C compiler, but a direct comparison is impossible. Some functions in the OCaml standard library are implemented with faster algorithms than equivalent functions in the libraries of other languages. OCaml is notable for extending ML-style type inference to a system in a general-purpose language. A foreign function interface for linking to C primitives is provided, portability is achieved through native code generation support for major architectures, IA-32, X86-64, Power, SPARC, ARM, and ARM64. OCaml bytecode and native code programs can be written in a multithreaded style, however, because the garbage collector of the INRIA OCaml system is not designed for concurrency, symmetric multiprocessing is unsupported. OCaml threads in the same process execute by time sharing only, there are however several libraries for distributed computing such as Functory and ocamlnet/Plasma. Ocamlcc is a compiler from OCaml to C, to complement the native compiler for unsupported platforms. OCamlJava, developed by INRIA, is a compiler from OCaml to the Java virtual machine, oCaPic, developed by Lip6, is a compiler from OCaml to PIC microcontroller

14.
Scheme (programming language)
–
Scheme is a functional programming language and one of the two main dialects of the programming language Lisp. Unlike Common Lisp, the main dialect, Scheme follows a minimalist design philosophy specifying a small standard core with powerful tools for language extension. Scheme was created during the 1970s at the MIT AI Lab and released by its developers, Guy L. Steele and Gerald Jay Sussman and it was also one of the first programming languages to support first-class continuations. It had a significant influence on the effort led to the development of Common Lisp. The Scheme language is standardized in the official IEEE standard and a de facto standard called the Revisedn Report on the Algorithmic Language Scheme, the most widely implemented standard is R5RS, a new standard, R6RS, was ratified in 2007. Scheme was originally called Schemer, in the tradition of other Lisp-derived languages like Planner or Conniver, the current name resulted from the authors use of the ITS operating system, which limited filenames to two components of at most six characters each. Currently, Schemer is commonly used to refer to a Scheme programmer, a new language standardization process began at the 2003 Scheme workshop, with the goal of producing an R6RS standard in 2006. This process broke with the earlier RnRS approach of unanimity, R6RS features a standard module system, allowing a split between the core language and libraries. A number of drafts of the R6RS specification were released, the version being R5. 97RS. A successful vote resulted in the ratification of the new standard, currently the newest releases of various Scheme implementations, such as Chez Scheme, Racket, Ikarus, Larceny and Ypsilon, support the R6RS standard. There is a reference implementation of the proposed implicitly phased libraries for R6RS, called psyntax. R6RS introduces numerous significant changes to the language, the source code is now specified in Unicode, and a large subset of Unicode characters may now appear in Scheme symbols and identifiers, and there are other minor changes to the lexical rules. Character data is now specified in Unicode. A new module system has introduced, and systems for exception handling are now standardized. Syntax-rules has been replaced with a more expressive syntactic abstraction facility which allows the use of all of Scheme at macro expansion time, the R6RS standard has caused controversy because it is seen to have departed from the minimalist philosophy. The Scheme Reports Process site has links to the working groups charters, public discussions, the ninth draft of R7RS was made available on April 15,2013. Scheme is primarily a functional programming language and it shares many characteristics with other members of the Lisp programming language family. Schemes very simple syntax is based on s-expressions, parenthesized lists in which an operator is followed by its arguments

15.
Smalltalk
–
Smalltalk is an object-oriented, dynamically typed, reflective programming language. Smalltalk was created as the language to underpin the new world of computing exemplified by human–computer symbiosis, the language was first generally released as Smalltalk-80. Smalltalk-like languages are in continuing development and have gathered loyal communities of users around them. ANSI Smalltalk was ratified in 1998 and represents the version of Smalltalk. There are a number of Smalltalk variants. The unqualified word Smalltalk is often used to indicate the Smalltalk-80 language, Smalltalk was the product of research led by Alan Kay at Xerox Palo Alto Research Center, Alan Kay designed most of the early Smalltalk versions, which Dan Ingalls implemented. A later variant actually used for work is now known as Smalltalk-72. Its syntax and execution model were very different from modern Smalltalk variants, after significant revisions which froze some aspects of execution semantics to gain performance, Smalltalk-76 was created. This system had a development environment featuring most of the now familiar tools, later a general availability implementation, known as Smalltalk-80 Version 2, was released as an image and a virtual machine specification. ANSI Smalltalk has been the standard language reference since 1998, two of the currently popular Smalltalk implementation variants are descendants of those original Smalltalk-80 images. Squeak is an open source implementation derived from Smalltalk-80 Version 1 by way of Apple Smalltalk, VisualWorks is derived from Smalltalk-80 version 2 by way of Smalltalk-802.5 and ObjectWorks. As an interesting link between generations, in 2001 Vassili Bykov implemented Hobbes, a machine running Smalltalk-80 inside VisualWorks. During the late 1980s to mid-1990s, Smalltalk environments—including support, training, ParcPlace Systems tended to focus on the Unix/Sun microsystems market, while Digitalk focused on Intel-based PCs running Microsoft Windows or IBMs OS/2. IBM initially supported the Digitalk product, but then entered the market with a Smalltalk product in 1995 called VisualAge/Smalltalk, easel introduced Enfin at this time on Windows and OS/2. Enfin became far more popular in Europe, as IBM introduced it into IT shops before their development of IBM Smalltalk, Enfin was later acquired by Cincom Systems, and is now sold under the name ObjectStudio, and is part of the Cincom Smalltalk product suite. In 1995, ParcPlace and Digitalk merged into ParcPlace-Digitalk and then rebranded in 1997 as ObjectShare, located in Irvine, ObjectShare was traded publicly until 1999, when it was delisted and dissolved. The merged firm never managed to find a response to Java as to market positioning. VisualWorks was sold to Cincom and is now part of Cincom Smalltalk, Cincom has backed Smalltalk strongly, releasing multiple new versions of VisualWorks and ObjectStudio each year since 1999

16.
Ceylon (programming language)
–
Ceylon is an object-oriented, strongly statically typed programming language with an emphasis on immutability, created by Red Hat. Ceylon programs run on the Java virtual machine, and can be compiled to JavaScript, the language design focuses on source code readability, predictability, toolability, modularity, and metaprogrammability. Ceylon is heavily-influenced by Javas syntax, but adds new features. One of the most novel aspects of Ceylon is its type system, Ceylon foregoes Javas primitive types and boxing in favor of a type system composed entirely of first-class objects. While this may cause boxing overhead in some situations, it makes the system more uniform. Ceylon allows for union and intersection types, in a fashion to TypeScript, Whiley. Union types, written A|B, allow a variable to have more than one type, union and intersection types are used to provide null safety. The top type of the Ceylon type hierarchy is the class Anything, since Object and Null are disjoint types, most regular types like Integer or List<String> are not nullable, a nullable type is the union Integer|Null, abbreviated Integer. Intersection types can be used to get a non-optional type out of a possibly-optional type and this is implemented in Ceylon with a pattern of limiting the instances of an abstract class at declaration to a limited set of objects. Another way to implement this pattern is with the new feature in Ceylon 1.2 where the objects are implemented as different named constructor declarations. Ceylon is strongly and statically typed, but also has support for type inference, the value keyword is used to infer the type of a variable, and the function keyword is used to infer the type of a function. The following two definition pairs are each equivalent, However, to make single-pass type inference possible, type inference is only allowed for non-toplevel, part of the source code is licensed under LGPL. Dart, has its own VM, compiles to JS, type system not very strict, supports mixins Fantom, compiles to JVM, type system not very strict, supports mixins Official website

17.
Fantom (programming language)
–
Fantom is a general purpose object-oriented programming language created by Brian and Andy Frank that runs on the Java Runtime Environment, JavaScript, and the. NET Common Language Runtime. Its primary design goal is to provide a standard library API that abstracts away the question of whether the code will run on the JRE or CLR. Like C# and Java, Fantom uses a curly brace syntax, the language supports functional programming through closures and concurrency through the Actor model. Fantom takes a middle of the approach to its type system. Fantoms type system is simple by design, all variables are statically typed, as they are in C# and Java. Fantom rejects generic types due to their complexity, but it does have a set of generic types, List, Map. Fantom can also take on the feel of a typed language through dynamic calls. Fantom has an easy to use reflection API and metaprogramming capabilities, Fantom is open source under the Academic Free License 3.0 and is available for Windows and Unix-like platforms. In Fantom, the unit of deployment is called a pod, Pods take on the role of namespaces, packages, and modules. They are stored as. pod files, which are zip files containing the FCode, the documentation, a pod can define any number of types for use in other libraries and applications. A pod name fully qualifies a type name, for example, fwt, Widget is distinct from webapp, Widget. If a pod contains a type named Main, then it can be executed on the line with, fan <podName> The Fantom build system can package a set of Pods into a JAR archive through build. Fantom ships with a windowing toolkit called the Fantom Widget Toolkit. Like Fantom, FWT was designed to be portable across several platforms and it is currently implemented on the JVM using the Standard Widget Toolkit as a backend. The JavaScript implementation is backed by the element and JavaFX. There are plans for a CLR implementation using Windows Forms, here is the classic Hello world program written in Fantom, Notice that Void is capitalized. This is because Void is a class, not a type in Fantom. The original name of the Fantom programming language was Fan, named after the neighborhood where the live in Richmond

18.
F Sharp (programming language)
–
F# is a strongly typed, multi-paradigm programming language that encompasses functional, imperative, and object-oriented programming methods. F# is most often used as a cross-platform Common Language Infrastructure language, F# is developed by the F# Software Foundation, Microsoft and open contributors. An open source, cross-platform compiler for F# is available from the F# Software Foundation, F# is also a fully supported language in Visual Studio and Xamarin Studio. Other tools supporting F# development include Mono, MonoDevelop, SharpDevelop, MBrace, plug-ins supporting F# exist for many widely used editors, most notably the Ionide extension for Atom and Visual Studio Code, and integrations for other editors such as Vim, Emacs, and Sublime Text. In the course of its development, the language has gone through several versions, F# uses an open development, the language evolution process is managed by Don Syme from Microsoft Research as the benevolent dictator for life for the language design, together with the F# Software Foundation. Earlier versions of the F# language were designed by Microsoft and Microsoft Research using a development process. F# originates from Microsoft Research, Cambridge, the Visual F# Tools for Visual Studio are developed by Microsoft. The F# Software Foundation developed the F# open-source compiler and tools, F# is a strongly typed functional-first language that uses type inference. The programmer does not need to declare types—the compiler deduces types during compilation, F# also allows explicit type annotations, and requires them in some situations. F# is a language using eager evaluation. Every statement in F#, including if expressions, try expressions, functions and expressions that do not return any value have a return type of unit. F# uses the let keyword for binding values to a name, for example, binds the value 7 to the name x. New types are defined using the type keyword, for functional programming, F# provides tuple, record, discriminated union, list, option, and result types. A tuple represents a set of n values, where n ≥0, the value n is called the arity of the tuple. A 3-tuple would be represented as, where A, B, a tuple can be used to store values only when the number of values is known at design-time and stays constant during execution. A record is a type where the members are named. The with keyword is used to create a copy of a record, as in, a discriminated union type is a type-safe version of C unions. For example, Values of the type can correspond to either union case

19.
Kotlin (programming language)
–
Kotlin is a statically-typed programming language that runs on the Java Virtual Machine and also can be compiled to JavaScript source code. Its primary development is from a team of JetBrains programmers based in Saint Petersburg, Kotlin was named Language of the Month in the January 2012 issue of Dr. Dobbs Journal. While not syntax compatible with Java, Kotlin is designed to interoperate with Java code and is reliant on Java code from the existing Java Class Library, in July 2011 JetBrains unveiled Project Kotlin, a new language for the JVM, which had been under development for a year. JetBrains lead Dmitry Jemerov said that most languages did not have the features they were looking for, however, he cited the slow compile time of Scala as an obvious deficiency. One of the goals of Kotlin is to compile as quickly as Java. In February 2012, JetBrains open sourced the project under the Apache 2 license, jetbrains hopes that the new language will drive IntelliJ IDEA sales. Kotlin v1.0 was released on February 15,2016 and this is considered to be the first officially stable release and JetBrains has committed to long-term backwards compatibility starting with this version. As in Scala and Groovy, semicolons are optional as a statement terminator, in addition to the classes and methods of object-oriented programming, Kotlin also supports procedural programming with the use of functions. As in C and C++, the point to a Kotlin program is a function named main. Perl and Unix/Linux shell script-style string interpolation is supported, example Kotlin makes a distinction between nullable and non-nullable datatypes. All nullable objects must be declared with a. postfix after the type name, operations on nullable objects need special care from developers, null-check must be performed before using the value. Kotlin provides null-safe operators to help developers, can be used to safely access a method or property of a possibly null object. If the object is null, the method will not be called, often referred to as the Elvis operator, An example of the use of the safe navigation operator, IntelliJ IDEA has plug-in support for Kotlin. IntelliJ IDEA15 is the first version to bundle Kotlin plugin in the IntelliJ Installer, JetBrains also has an Eclipse plug-in. One of the applications of Kotlin is Android development. The platform has been stuck on Java 6 and Kotlin introduces many improvements for programmers such as null-pointer safety, extension functions. Accompanied by full Java compatibility and good IDE support it is intended to improve readability, give an easier way to extend Android SDK classes. According to the Kotlin website, Tuenti and Prezi are using Kotlin in the backend, dripStat has done a writeup of their experience with Kotlin

20.
Lasso (programming language)
–
Lasso is an application server and server management interface used to develop internet applications and is a general-purpose, high-level programming language. Lasso includes a simple template system allowing code to control generation of HTML, Lasso is object-oriented and every value is an object. It also supports programming through unbound methods. The language uses traits and multiple dispatch extensively, Lasso also supports Query Expressions, allowing elements within arrays and other types of sequences to be iterated, filtered, and manipulated using a natural language syntax similar to SQL. Lasso is often used as a language, and also used in a wide range of non-scripting contexts. Lasso code can be packaged into standalone executable programs called LassoApps, the Lasso Server application server runs as a system service and receives requests from the web server through FastCGI. It then hands the request off to the appropriate Lasso Instance, multiple individual instances are supported, allowing one server to handle multiple sites, each as separate processes. The server uses a high performance IO-based green threading system designed for multi-core systems, Lasso can be compared to the server-side scripting languages PHP and Python, ColdFusion, Ruby, etc. Free for development, Lasso allows partial access to its source code, licensing comes in both SAS and stand-alone versions. Lasso began in the mid-1990s when early web developers were attempting to connect Apples FileMaker Pro database with the World Wide Web, at this time, Blue World experimented with improvements for the CGI in the Frontier scripting environment, which inspired the name Lasso. Further need for improvement drove the creation of a C-based CGI which was released as Lasso 1.0. At this point Lasso only worked with FileMaker Pro 3. x and WebSTAR, Blue World also made frequent appearances and was known as a leading company at MacWorld conferences. Following the release of the Lasso 1.2 lineup in January 1997, Blue World and the Bonfantis entered private talks with Claris, the division of Apple Computer. Claris eventually licensed the post-version-1.2 Lasso source code, and with the help of Vince, including the Lasso-like Web Companion in FileMaker 4.0 helped grow popularity for Lasso in the fast-growing Macintosh web development community. Blue World continued developing Lasso with Kyle Jessup becoming Lassos lead programmer, Lasso 2.0 was released in July 1997, introducing some fundamental shifts in how Lasso could be used. On February 26,2002, Blue World released Lasso 5, Lasso 5 included, among many updates, a completely rewritten architecture, and an embedded MySQL database. Though Lasso 5 still spoke to a FileMaker database, FileMaker as a data source remained relatively slow compared to an SQL engine, and was prohibitively more expensive. Lasso 5 also added support for Apache HTTP Server natively under OS X, Windows, and Linux, joining Webstar 5, AppleShare IP and this drove closer ties to a classic LAMP server architecture

21.
Red (programming language)
–
Red is a computer programming language. Red was made to overcome the limitations of the programming language Rebol, introduced in 2011 by Nenad Rakocevic, Red is both an imperative and functional programming language. Its syntax and general usage overlaps that of the interpreted Rebol language, the implementation choices of Red intend to create a full stack programming language, Red can be used for extremely high-level programming as well as low-level programming. Key to the approach is that the language has two parts, Red/System and Red, Red/System is similar to C, but packaged into a Rebol lexical structure — for example, one would write if x > y instead of if. Red is a language capable of meta-programming, with semantics similar to Rebols. Reds runtime library is written in Red/System, and uses an approach, it compiles what it can deduce statically. The project roadmap includes a compiler for cases in between, but this has not yet been implemented. Red seeks to remain independent of any other toolchain, it does its own code generation and it is therefore possible to cross-compile Red programs from any platform it supports to any other, via a command-line switch. Both Red and Red/System are distributed as software under the modified BSD license. The runtime library is distributed under the more permissive Boost Software License, Red was introduced in the Netherlands on February 2011 at the Rebol & Boron conference by its author Nenad Rakocevic. In September 2011, the Red programming language was presented to an audience during the Software Freedom Day 2011. Rakocevic is a long-time Rebol developer known as the creator of the Cheyenne HTTP server, reds syntax and semantics are very close to those of Rebol. Like Rebol, it strongly supports metaprogramming and domain-specific languages and is therefore an efficient tool for dialecting. Red builds on a dialect called Red/System, which provides system programming facilities, Red is easy to embed and very lightweight. It is also able to cross-compile to various platforms as well as creating packages for some platforms via bridges intended for implementation of Red on the former. com red on GitHub

22.
Programming language
–
A programming language is a formal computer language designed to communicate instructions to a machine, particularly a computer. Programming languages can be used to programs to control the behavior of a machine or to express algorithms. From the early 1800s, programs were used to direct the behavior of such as Jacquard looms. Thousands of different programming languages have created, mainly in the computer field. Many programming languages require computation to be specified in an imperative form while other languages use forms of program specification such as the declarative form. The description of a language is usually split into the two components of syntax and semantics. Some languages are defined by a document while other languages have a dominant implementation that is treated as a reference. Some languages have both, with the language defined by a standard and extensions taken from the dominant implementation being common. A programming language is a notation for writing programs, which are specifications of a computation or algorithm, some, but not all, authors restrict the term programming language to those languages that can express all possible algorithms. For example, PostScript programs are created by another program to control a computer printer or display. More generally, a language may describe computation on some, possibly abstract. It is generally accepted that a specification for a programming language includes a description, possibly idealized. In most practical contexts, a programming language involves a computer, consequently, abstractions Programming languages usually contain abstractions for defining and manipulating data structures or controlling the flow of execution. Expressive power The theory of computation classifies languages by the computations they are capable of expressing, all Turing complete languages can implement the same set of algorithms. ANSI/ISO SQL-92 and Charity are examples of languages that are not Turing complete, markup languages like XML, HTML, or troff, which define structured data, are not usually considered programming languages. Programming languages may, however, share the syntax with markup languages if a computational semantics is defined, XSLT, for example, is a Turing complete XML dialect. Moreover, LaTeX, which is used for structuring documents. The term computer language is used interchangeably with programming language

23.
Criticism of Java
–
A number of criticisms have been leveled at the Java programming language and the Java software platform for various design choices in the language and platform. Additionally, Java, especially its early versions, has criticized for its performance compared to other programming languages. Developers have also remarked that differences in various Java implementations must be taken into account when writing complex Java programs that must be used across these implementations and this limited the features that could be provided by this addition as compared to other languages. Because generics were implemented using type erasure the actual type of a template parameter E is unavailable at runtime. Thus, the operations are not possible in Java, However, the following is, and will throw a ClassCastException on run-time. By design, Java encourages programmers to think of a solution in terms of nouns interacting with each other. In many other languages, there is support for functions as a top-level construct. Java version 8 introduced some functional programming features, similarly Joel Spolsky in 2005, criticised Java as overfocused part of universities curriculum in his essay The Perils of JavaSchools. Others, like Ned Batchelder, disagree with Spolsky for criticizing the parts of the language that he found difficult to understand, Java lacks native unsigned integer types. Unsigned data is generated from programs written in C and the lack of these types prevents direct data interchange between C and Java. Unsigned large numbers are used in a number of numeric processing fields, including cryptography. Although it is possible to circumvent this problem with conversion code and using larger data types. In all cases, the memory consumed may increase by a factor of up to two, and any logic that depends on the rules of twos complement overflow must typically be rewritten. If abstracted using functions, function calls become necessary for operations which are native to some other languages. Alternatively, it is possible to use Javas signed integers to emulate unsigned integers of the same size, some support for unsigned integer types were provided in JDK8, but not for unsigned bytes and with no support in the Java language. Java has been criticized for not supporting the capability of implementing user-defined operators, according to critics, this can make the code much less readable, especially for classes representing mathematical objects, such as complex numbers, matrices, etc. A form of overloading is implemented in the language, specifically, other than for adding numeric primitive types. However, this form of overloading is a feature of the language

24.
Java bytecode
–
Java bytecode is the instruction set of the Java virtual machine. Each bytecode is composed of one, or in some cases two bytes that represent the instruction, along with zero or more bytes for passing parameters. Of the 256 possible byte-long opcodes, as of 2015,198 are in use,54 are reserved for future use, a Java programmer does not need to be aware of or understand Java bytecode at all. Many instructions have prefixes and/or suffixes referring to the types of operands they operate on and these are as follows, For example, iadd will add two integers, while dadd will add two doubles. The const, load, and store instructions may take a suffix of the form _n. The maximum n for const differs by type, the const instructions push a value of the specified type onto the stack. For example, iconst_5 will push an integer 5, while dconst_1 will push a double 1, there is also an aconst_null, which pushes null. The n for the load and store instructions specifies the location in the table to load from or store to. The aload_0 instruction pushes the object in variable 0 onto the stack, istore_1 stores the integer on the top of the stack into variable 1. For variables with higher numbers the suffix is dropped and operands must be used, some projects provide Java assemblers to enable writing Java bytecode by hand. Assembly code may be generated by machine, for example by a compiler targeting a Java virtual machine. Java syntax is used for class or interface definition, method bodies are specified using bytecode instructions. Krakatau Bytecode Tools, currently contains three tools, a decompiler and disassembler for Java classfiles and an assembler to create classfiles, lilac, an assembler and disassembler for the Java virtual machine. Some processors can execute Java bytecode natively, such processors are termed Java processors. The Java virtual machine provides some support for dynamically typed languages, JSR292 added a new invokedynamic instruction at the JVM level, to allow method invocation relying on dynamic type checking. The Da Vinci Machine is a virtual machine implementation that hosts JVM extensions aimed at supporting dynamic languages. All JVMs supporting JSE7 also include the invokedynamic opcode, the bytecode can be viewed as text using F3

25.
C (programming language)
–
C was originally developed by Dennis Ritchie between 1969 and 1973 at Bell Labs, and used to re-implement the Unix operating system. C has been standardized by the American National Standards Institute since 1989, C is an imperative procedural language. Therefore, C was useful for applications that had formerly been coded in assembly language. Despite its low-level capabilities, the language was designed to encourage cross-platform programming, a standards-compliant and portably written C program can be compiled for a very wide variety of computer platforms and operating systems with few changes to its source code. The language has become available on a wide range of platforms. In C, all code is contained within subroutines, which are called functions. Function parameters are passed by value. Pass-by-reference is simulated in C by explicitly passing pointer values, C program source text is free-format, using the semicolon as a statement terminator and curly braces for grouping blocks of statements. The C language also exhibits the characteristics, There is a small, fixed number of keywords, including a full set of flow of control primitives, for, if/else, while, switch. User-defined names are not distinguished from keywords by any kind of sigil, There are a large number of arithmetical and logical operators, such as +, +=, ++, &, ~, etc. More than one assignment may be performed in a single statement, function return values can be ignored when not needed. Typing is static, but weakly enforced, all data has a type, C has no define keyword, instead, a statement beginning with the name of a type is taken as a declaration. There is no function keyword, instead, a function is indicated by the parentheses of an argument list, user-defined and compound types are possible. Heterogeneous aggregate data types allow related data elements to be accessed and assigned as a unit, array indexing is a secondary notation, defined in terms of pointer arithmetic. Unlike structs, arrays are not first-class objects, they cannot be assigned or compared using single built-in operators, There is no array keyword, in use or definition, instead, square brackets indicate arrays syntactically, for example month. Enumerated types are possible with the enum keyword and they are not tagged, and are freely interconvertible with integers. Strings are not a data type, but are conventionally implemented as null-terminated arrays of characters. Low-level access to memory is possible by converting machine addresses to typed pointers