STUQ.nl

In this tutorial you learn how to integrate Scala in your existing Maven Java projects. From configuring the project’s pom file to adding your first Scala code. Tip: Try to hide this inside a large code commit, and your co-workers will not notice you have added Scala support.. surprise!

Step 1: Configure the Maven Scala Plugin in your pom.xml

To building the Scala source code into Java bytecode, you can use the Maven Scala Plugin.
Add the <plugins> section somewhere in your pom.xml (in the <build> section):

<project>
    <build>
        <plugins>
            <plugin>
                <groupId>org.scala-tools</groupId>
               <artifactId>maven-scala-plugin</artifactId>
                <executions>
                    <execution>
                        <goals>
                            <goal>compile</goal>
                            <goal>testCompile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
<project>

Alternative Step 1: Circular dependencies

Update: Do you need to build circular dependencies between Java and Scala? Put this in your pom.xml instead.

Add the <plugins> section somewhere in your pom.xml (in the <build> section):

<project>
    <build>
        <plugins>
            <plugin>
                <groupId>org.scala-tools</groupId>
               <artifactId>maven-scala-plugin</artifactId>
 
                <executions>
                    <execution>
                        <id>compile</id>
                        <goals>
                        <goal>compile</goal>
                        </goals>
                        <phase>compile</phase>
                    </execution>
 
                    <execution>
                        <id>test-compile</id>
                        <goals>
                        <goal>testCompile</goal>
                        </goals>
                        <phase>test-compile</phase>
                    </execution>
 
                    <execution>
                        <phase>process-resources</phase>
                        <goals>
                            <goal>compile</goal>
                        </goals>
                    </execution>
                </executions>
            </plugin>
        </plugins>
    </build>
<project>

Step 2: Add Maven Scala Plugin repository

Before the Maven Scala Plugin can be loaded, your Maven installation needs to know where to find the plugin and the other Scala dependencies. These items can be found in the Scala Tools repository. Add the following to your project-specific pom.xml. (You can also choose to add this repository to your ~/.m2/settings.xml)

Add this to your pom.xml in the <project> section:

<pluginRepositories>
    <pluginRepository>
        <id>scala</id>
        <name>Scala Tools</name>
        <url>http://scala-tools.org/repo-releases/</url>
        <releases>
            <enabled>true</enabled>
        </releases>
        <snapshots>
            <enabled>false</enabled>
        </snapshots>
    </pluginRepository>
</pluginRepositories>

<repositories>
    <repository>
        <id>scala</id>
        <name>Scala Tools</name>
        <url>http://scala-tools.org/repo-releases/</url>
        <releases>
            <enabled>true</enabled>
        </releases>
        <snapshots>
            <enabled>false</enabled>
        </snapshots>
    </repository>
</repositories>

Step 3: Add Scala dependency to your pom.xml

Now that all Scala repositories and the Maven Scala plugin is configured, you can add the Scala dependency to your project’s pom.xml. Add the following code to the >dependencies> section of your pom.xml:

<dependency>
    <groupId>org.scala-lang</groupId>
    <artifactId>scala-library</artifactId>
    <version>2.7.2</version>
</dependency>

Step 4: Add some Scala code

The Maven Scala plugin expects your Scala code in /src/main/scala
Create the scala directory.
Put the following code in a file called /src/main/scala/demo.scala:

object HelloWorld {
  def main(args: Array[String]) {
    println("Hello, world!")
  }
}

Ready!

You can now execute mvn package to build your project, mvn test to test your project, and the Scala class will get built. Let me know if you got it working, I’d love to hear your comments.

Many people do not know about the programming language Scala, or why they should care. I think you should care, because Scala has some nice secrets from which you can learn a lot. Scala is a great excuse for learning new things. Even if you never use Scala again, it can be a nice addition to any programmer’s toolbox.

No matter what language you are programming in, it is a good habit to look at new developments. New ways of doing stuff keeps your brain alive. You become a better programmer with your existing tools. And maybe you get some new tools in the process.

So, onto the first question, What is Scala?

What is Scala?

Scala is a relatively young programming language. It has the following distinguishing features:

• Java compatible bytecode
• Functional programming language

Java compatible bytecode

Scala is a bit special because it runs on the Java virtual machine. This means that Scala code will compile into Java compatible bytecode. For the Java programmers, this means you can integrate Scala directly into your Java projects. This means that it is possible to create a Java interface and implement it in Scala. Or call Scala methods from Java. It also means that you can use a truckload of existing Java libraries with Scala.

This is very neat, as you do not have to convert entire projects to Scala. You can use Scala in the spots where it fits, and use Java as the main language. This makes Scala look a lot more interesting, especially in big Java shops.

Functional programming language

Scala is a functional programming language. To give a tip-of-the-iceberg-idea: every function is an object. Scala gives the possibility to pass values, but also to pass calculations to methods. This is very powerful and opens a lot of doors to all kinds of new programming constructs.

In Scala, you can make the following constructs very easily:

• Anonymous functions
• Pass a function as argument to another function
• Nested functions
• Function as return value of a function

The Hello World example

As any post about a new programming language, I cannot omit the Hello World example.

So, download Scala, copy/paste the following code and get started!

object HelloWorld {
  def main(args: Array[String]) {
    println("Hello, world!")
  }
}

Further reading

• The busy Java developers guide to Scala
• The Scala Programming Language