1. Why Scala?
2. Who is responsible for Scala?
3. How stable are Scala applications?
4. What JRE should I use to run Scala?
5. Under which license is Scala available?
6. How can I distribute a Scala application?
7. Where do I get the newest version with all the cool bleeding-edge stuff?
8. What do I need to know about class-loaders?
9. Where can I search for documentation and articles about Scala?
10. Why are monads useful in Scala?

You can also go back to the FAQ page.

The Scala compiler is quite stable and generates stable byte-code that will run successfully on most JREs. Only rarely, when pushing the rich possibilities of the language, problems can appear. But since Scala is actively developed, they will usually be fixed quickly when posted on the Scala bug-tracking system.

As a workaround you can always implement the problematic part in Java.

Any JRE supporting Java 1.4 or 5.0 or 6.0 byte-code should work. We regularly test Scala on:

• Sun HotSpot JRE for Java 1.4.2, on Linux/x86 and Windows,
• Sun HotSpot JRE for Java 5.0, on Linux/x86, Windows, Mac OS X/x86 and Mac OS X/PPC 1),
• Sun HotSpot JRE for Java 6.0, on Linux/x86, Windows and Mac OS X/x86
• IBM J9 JRE 2.3 for Java 5.0 on Linux/x86.
• IBM J9 JRE 2.4 for Java 6.0 on Linux/x86.

HotSpot 1.6 is the standard JRE we use for Scala, and should be the most stable. We have however observed significant speed improvements on Linux when using J9.

Scala is distributed under a BSD-style license. This means that the Scala binaries can be distributed along your own binaries with virtually no strings attached.

If you want to distribute a library or a development tool, you should consider uploading it to the scala-dev Scala bazaar so that other Scala users can access it.

If you want to distribute a standalone application, you should follow the same procedure as with any program for the backend you are targeting. For the JVM, just remember to include scala-library.jar in addition to a jar of all your Scala-compiled class files.

See Compressed Executable JAR for a way to tightly compress the Scala library jar and your application.

You can get a distribution built from recent sources in the nightly builds repository.

To get the very latest Scala compiler and library, you need to use the development version from the SVN repository and build it yourself. To do that, you need to:

1. Using SVN, download the sources to your machine:

   $ svn checkout http://lampsvn.epfl.ch/svn-repos/scala/scala/trunk/ scala
   $ cd scala

2. Using Ant, compile your very own distribution of the sources:

   $ ant dist

3. You could run (UNIX only) the test suite to make sure this particular snapshot is a good one:

   $ test/scalatest

4. A new Scala distribution will now be available in:

   dists/latest/

5. To update to the latest sources, run:

   $ svn update
   $ ant dist

Nothing. There used to be a limitation in early versions of Scala 2 that forced user classes to be in the same class-loader as the Scala library. This is no longer the case.

As the “scala” word has many different meanings, it’s sometime difficult to search for documentation about Scala on Google and similar search engines. Carlo Bonamico has created a specialized search engine (using http://www.google.com/coop/cse/overview) at

http://www.carlobonamico.com/scala.php

which focuses search on a list of Scala-related websites and mailing lists. It’s also possible to contribute to the search engine by submitting additional sites.

People new to functional programming frequently ask why monads are useful, especially in a language like Scala which allows side effects. This section lists quotes from people who have used monads to good result. It avoids being abstract (monads have mathematical grounding) and code (here’s how you build a JSON parser with monads). The idea is to give enough motivation to justify the effort to learn and use monads.

1. Continuations for a chat server and NIO

“Thomas Hofer did a Scala framework for Jetty – a chat server program just shrunk from 400 lines to 100 lines using his library, and the 100 lines are much easier to read and cleaner than the original 400 lines. Antoine Yersin did a library to wrap java.nio. Again client programs become dramatically simpler and shorter.”

“Both libraries advance the state of the art and have great potential in my opinion. They are both based on a little class in the standard Scala library called scala.Responder. This class embodies the standard monad of continuations.” – Martin Odersky

The authoritative source is Martin Odersky’s pronunciation in http://video.google.com/videoplay?docid=553859542692229789 at about 1:16 into the video. The two ‘a’s in Scala are soft, pronounced like the two ‘a’s in “Java”. (However, Martin also acknowledged the “American” pronunciation with the first ‘a’ being a hard ‘a’ as in “scalability”.)