Programming Scala, 3rd Edition (Forthcoming)
README for the Code Examples
|August 11, 2014||2nd edition examples|
|May 27, 2019||Updated for Scala 2.12 and 2.13|
|June 18, 2019||New support for Maven builds, courtesy of oldbig|
|October 12, 2019||Updated for Scala 2.13.1, sbt 1.3.2, and other dependencies. Also now compiles with JDK 11|
|October 13, 2019||Renamed the repo from
|December 31, 2019||Renamed the
|March 1, 2020||Completed conversion to Scala 3|
|March 20, 2020||Started incorporating new Scala 3 syntax, idioms|
This repo contains all the code examples to be included in Programming Scala, Third Edition. (The second edition is available here.) There are also many code files in this distribution that aren't included in the book.
When the second edition was published, the examples used Scala 2.11. The code has since been updated to also compile with Scala 2.12 and 2.13. Many examples are being improved, in part so they compile with newer library versions and with the stricter compiler flags now used. (ScalaTest, in particular, has changed a lot since the second edition.)
If you want the example code for the second edition (with a few bug fixes), download the tagged 2.1.0 build or check out the
release-2.1.0 branch. The latest
2.X.Y release and
release-2.X.Y branch include all the updates for 2.12 and 2.13. (No more
release-2.X.Y releases are planned.) The third edition code for Scala 3 will be tagged with
XYZ starting at
001 until the edition is published. Afterwards,
release-3.X.Y will be used.
How the Code Is Used in the Book
In the book's text, when an example corresponds to a file in this distribution, the listing begins with a path in a comment with the following format:
And similarly for Java files (yes, there are Java files!). Following the usual conventions, tests are in
Use these comments to find the corresponding source file. This archive also contains MUnit and ScalaCheck unit tests to validate some of the code. Most of these tests are not reproduced in the text of the book, except when discussing testing itself.
The examples include "scripts" that are run with the
scala command (or within SBT using the
console), source files that are compiled with
scalac, source files that deliberately fail to compile to demonstrate common errors, and other example files that aren't part of the build.
To keep these different kinds of files straight and to support building with SBT, the following conventions are used for the files:
src/main/scala/.../*.scala- All Scala 3 source files built with SBT.
src/test/.../*.scala- All Scala 3 test source files built and executed with SBT.
src/script/.../*.scala- "Script" files that won't compile with
scalac, but can be interpreted with the
src/*/scala-2/.../*.scala- All Scala 2 source files that won't compile with Scala 3. They are not built with SBT.
src/extra/.../*.scala- Extra examples that aren't part of the SBT build, for example, an Apache Spark example that is not built so that the Spark dependencies aren't added to the build.
Required and Optional Tools
To build and run the examples, all you need Java 8 or newer and SBT. SBT is the de-facto standard build tool for Scala. When you run SBT, it will bootstrap itself with the correct version of its jar file, Scala, and project dependencies, which are specified in the
build.sbt file in the root directory and other build files in the
Follow these installation instructions.
If you want to install Scala separately and Scala's Scaladocs, go to scala-lang.org, but this isn't required.
Editors, IntelliJ, Visual Studio Code, and Other IDEs
Most editors and IDEs now have some sort of Scala support:
- IntelliJ: Either the Community or Ultimate additions will work. Install the Scala plugin, which has built-in support for SBT.
- Visual Studio Code: Use the new Scala Metals plugin instead of older plugins.
- Eclipse Scala IDE: Old, no longer recommended.
After installing the required plugins, load this project in your IDE, which should detect and use the SBT project automatically. For eclipse, run the
sbt eclipse task to generate project files, then import them.
Building the Code Examples
After installing SBT, open a command/terminal window and run the
sbt test command. By default, it now uses the dotc preview for Scala 3.
You'll see lots of output as it downloads all the dependencies, compiles the code and runs the tests. You should see
[success] messages at the end.
SBT is discussed in more detail in the book and the SBT website, but a few useful commands are worth mentioning here.
If you start
sbt without any arguments, it puts you into an interactive mode where you can type commands. Use control-D to exit this mode. Once at the SBT prompt (
sbt:Programming Scala, Third Edition - Code examples>), try the following commands, where each
# starts a comment; don't type those!
help # help on tasks and settings clean # delete all build outputs compile # compile the source, but not test code test # compile source and test code, if necessary and run the tests. ~test # continuously compile and test when source changes are saved. console # run the Scala REPL; dependencies and code are on the CLASSPATH tasks # show the most common tasks (commands). tasks -V # REALLY show ALL tasks
~ prefix causes the task to be run continuously each time source code changes are saved. This promotes continuous TDD (test-driven development) and is one of my favorite features!
Outside of SBT, you could, in principle, run the script files manually at the console/terminal prompt.
However, many of the scripts require other project code that has been compiled (which is in
target/scala-X.Y/classes) and occasionally third-party libraries that are part of the project dependencies. Hence, it's easier to test the scripts using the SBT
console task. Use the REPL's
:load src/script/scala/.../Foo.scala feature to load and run the script.
I welcome feedback on the Book and these examples. Please post comments, corrections, etc. to one of the following places:
- This GitHub repo's Gitter channel or Issues
- The book's Twitter account, @ProgScala
- The O'Reilly book and errata sites, after publication.
There is also a dedicated site for the book where occasional updates, clarifications, corrections, and lame excuses will be posted: programming-scala.org.