Apart from being the build tool of choice for most Scala projects, SBT provides some very interesting features besides the ones provided by a conventional build tool.

To begin with, SBT can be configured using a simple Scala-based DSL and extended to use a full-fledged configuration with Scala as the project demands.

SBT uses incremental recompilation to reduce the compilation time of the Scala code. An incremental compiler will only compile what needs to be recompiled after changes. It also keeps the compiler's JVM up and running with the project's compiled code to prevent the load time.

SBT commands can be run in a triggered execution mode. That is, if opted by the user, specific tasks will be run whenever the user makes a change in any of the source code. This was originally meant for continuous compilation, but has now been extended for various other tasks. It is also possible to run multiple commands in this mode.

SBT provides support for testing with ScalaCheck, specs, and ScalaTest. Additionally, JUnit tests can also be run by using a plugin (junit-interface). SBT allows the user to run tests selectively or run all the tests. It also allows running only those tests that failed earlier or were excluded earlier or have a dependency on the recompiled code that is run.

SBT can start the Scala REPL with the project loaded in the classpath. One could call the methods defined in the project code within the REPL.

SBT can be configured to have subprojects. This provides better means for achieving modularity. Dependent modules can be clubbed using a single build and desired modules can be made completely independent of others.

SBT allows inclusion of external projects using their path or URL. This means it's also possible to include Git repositories as a dependency for the project. This makes the developer's life a lot simpler as he/she can easily have a project that depends on another project.

SBT runs tasks in parallel. Task parallelism refers to running one or more independent tasks concurrently. Task parallelism ensures efficient and scaleable use of resource systems. This is really useful for running tests in parallel.

SBT supports the inclusion of libraries as unmanaged or managed dependencies; that is, libraries can simply be included by adding the corresponding JAR in the lib directory or by specifying the dependencies in the build definition. SBT uses Apache Ivy to implement managed dependencies.

There are plugins to support SBT in Sublime Text, IntelliJ Idea, Eclipse, and Netbeans IDE. This makes it easier and simpler to adopt SBT.

SBT can either be installed from a package or manually.

$ port install sbt 

$ brew install sbt 

$ set SCRIPT_DIR=%~dp0 
$ java -Xmx512M -jar "%SCRIPT_DIR%sbt-launch.jar" %*

java -Xms512M -Xmx1536M -Xss1M -XX:+CMSClassUnloadingEnabled -XX:MaxPermSize=384M -jar `dirname $0`/sbt-launch.jar "[email protected]"

$ chmod u+x ~/bin/sbt

$ sbt --version
sbt launcher version 0.12.1

The following diagram shows the basic directory structure of a Scala SBT:

SBT recommends, and uses, the standard Maven project directory structure by default.

The files generated by SBT are written in the target directory within the project folder by default.

Let's write a program that checks for palindromes. Create Introduction.scala:

package Chapter1 

object Introduction extends App { 

  def isPalindrome(word: String) = { 
    val modifiedWord = word.toLowerCase.replaceAll("[^a-z0-9]", "") 
    val reversed = modifiedWord.reverse 
    modifiedWord == reversed 
  } 

  println("Is 'Herculaneum' a palindrome? " + isPalindrome("Herculaneum")) 
}

The IntroSpec.scala file is as follows:

import Chapter1.Introduction 
import org.specs2.mutable._ 

class IntroSpec extends Specification{ 
  "The phrase 'Never odd or even'" should{ 
    "be a palindrome" in { 
      Introduction.isPalindrome("Never odd or even") must beTrue 
    } 
  } 

  "The phrase 'Mr. Owl ate my metal worm'" should{ 
    "be a palindrome" in { 
      Introduction.isPalindrome("Mr. Owl ate my metal worm") must beTrue 
    } 
  } 

  "The date '20:02 02/20 2002'" should{ 
    "be a palindrome" in{ 
      Introduction.isPalindrome("20:02 02/20 2002") must beTrue 
    } 
  } 

}

The build file is used to specify the basic build settings and manage dependencies. We will see the build file in detail in the next chapter. It should be similar to the following:

name := "Introduction"

version := "1.0"

scalaVersion := "2.9.1"

resolvers ++= Seq("snapshots" at "http://oss.sonatype.org/content/repositories/snapshots",
  "releases" at "http://oss.sonatype.org/content/repositories/releases")

libraryDependencies ++= Seq(  "org.specs2" %% "specs2" % "1.12.3" % "test")

From the terminal/command prompt, go to the project directory:

$ cd introduction

To compile the project, use the following command:

$ sbt compile

The result will be as follows:

[info] Loading project definition from /home/introduction/project 
[info] Set current project to Introduction (in build file:/home/introduction/) 
[success] Total time: 0 s, completed 

To run the tests, use the following command:

$ sbt test

The result will be as follows:

[info] Loading project definition from /home/introduction/project 
[info] Set current project to Introduction (in build file:/home/introduction/) 
[info] IntroSpec 
… 
[info] Passed: : Total 3, Failed 0, Errors 0, Passed 3, Skipped 0 
[success] Total time: 5 s, completed 

To run the project, use the following command:

$ sbt run

The result will be as follows:

[info] Loading project definition from /home/introduction/project 
[info] Set current project to Introduction (in build file:/home/introduction/) 
[info] Running Chapter1.Introduction 
Is 'Herculaneum' a palindrome? false 
[success] Total time: 0 s, completed

It is also possible to run sbt in batch mode, that is, multiple commands separated by spaces. Execution will happen in the given order. Commands that take arguments must be enclosed in quotes.

The clean command is used to delete all the generated files in the target folder:

$ sbt clean compile test

The result will be as follows:

[info] Loading project definition from /home/introduction/project 
… 
[info] Passed: : Total 3, Failed 0, Errors 0, Passed 3, Skipped 0 
[success] Total time: 7 s, completed

While you are still in your project folder, type sbt in the terminal/command prompt:

$ sbt

It will load the required JAR files, and finally, result in an SBT shell that looks like the following:

[info] Loading project definition from /home/introduction/project 
[info] Set current project to Introduction (in build file:/home/introduction/) 
> 

Once the shell has started, you can compile, test, or run the project with compile, test, and run commands respectively:

>compile
[success] Total time: 0 s, completed

> test 
[info] IntroSpec 
.....................................
[info] Passed: : Total 3, Failed 0, Errors 0, Passed 3, Skipped 0 
[success] Total time: 2 s, completed

>run 
[info] Running Chapter1.Introduction 
Is 'Herculaneum' a palindrome? false 
[success] Total time: 0 s, completed

Typing console at the command prompt will open Scala REPL with the project's classpath, where you can try out live Scala examples based on your project's code. For example, consider the following:

> console 
[info] Starting scala interpreter... 
…
scala>

Let's run our palindrome function here:

scala> Chapter1.Introduction.isPalindrome("hello") 
res0: Boolean = false 

You could try running other functions as an exercise.

> ~run 
[info] Running Chapter1.Introduction 
Is 'Herculaneum' a palindrome? false 
[success] Total time: 0 s, completed Apr 11, 2013 4:04:08 PM 
1. Waiting for source changes... (press enter to interrupt) 

[info] Compiling 1 Scala source to /home/introduction/target/scala-2.9.1/classes... 
[info] Running Chapter1.Introduction 
Is 'HelloWorld' a palindrome? false 
[success] Total time: 1 s, completed Apr 11, 2013 4:04:51 PM 
2. Waiting for source changes... (press enter to interrupt) 
[info] Compiling 1 Scala source to /home/introduction/target/scala-2.9.1/classes... 
[info] Running Chapter1.Introduction 
Is 'Herculaneum' a palindrome? false 
[success] Total time: 1 s, completed Apr 11, 2013 4:05:11 PM 
3. Waiting for source changes... (press enter to interrupt) 

In this chapter, we saw how to build a simple Scala project in SBT and execute basic operations, such as compile, test, and run. In the following chapters, we will see how we can customize the build for our project based on various settings.