As a first step into learning Scala and as one who is familiar with Java, let us compare the customary Helloworld programs in Java and Scala. You might already know that to run a Java program, there must be a public class with a main method that takes one parameter, a String[], and has a void return type. For example:

package javaapplication;
public class Main {
   public static void main(String[] args) {
       System.out.println("Hello World");
   }
}

In Scala, an equivalent program looks something as follows -

 package scalaapplication
 object Main {
def main(args: Array[String]): Unit = {
println("Hello World")
}
 }

The output of both of the above programs is to print out Hello World. We compare and contrast the first programs in Java and Scala as follows:

• Both the programs begin with a package declaration. While the package statement or rather every statement in the Java program ends with a semi-colon, semicolon is not mandatory in the Scala program. In a Scala program, the compiler does not care whether a statement ends with a semicolon or not. Newline marks end of a statement and beginning of another. Semicolon is required though when multiple statements are written in a single line.

• While import statement is not shown in the above simple programs, they can both be part of a program in Java as well as Scala. Scala provides an easier and more concise way to import multiple statements as we will see in a later post.

• The major contrast between the two programs is that while the Java program has a class declaration, the Scala program has an object declaration.

Conceptually, a class is a blueprint for objects. An object is a concrete instance of a class.

In Java, we create an object using the new keyword followed by the class name. In Scala, we can directly define an object as shown above. We can also, of course, define classes and create objects using new keyword as in Java. The reason why we have defined an object instead of a class in the equivalent Scala program is described in a short while.

• Before we move on, in both programs, the Java class and the Scala object are public. In Java, the modifier named public needs to be used to mark a class/class member as public. In Scala, by default a class/class member is public. That is, when there is no access modifier, it means that the class/class member has  public access.

• Main Methods are defined in very similar yet different ways in Java and Scala programs. An illustration for the main method definitions as they compare with each other in the two languages follows -

def is the keyword that marks the beginning of any function definition in Scala. There is no such equivalent keyword in Java. The main point of difference is the absence of the static keyword in the Scala main method definition.

As Scala is a purely objected oriented language, there are no static things in Scala. Nevertheless, in order to achieve a similar behavior, Scala allows defining of something called as singleton objects. Just for now, a singleton object is one which looks like a class definition but with keyword object instead of class. In the above Scala program, Main is a standalone singleton object. To put it simplistically, for a Java programmer, a singleton object in Scala, is an equivalent holder of static methods if it were Java. So, now we know why we have defined an object in the above Scala program instead of a class.

The next important thing that can be noticed is the keyword ‘Unit‘ in the Scala main method definition. Unit is a return type for a function. Unit is used as a result type in a method, if all the method does is produce a side effect and not return any specific value as such. In our case, the side effect is printing out “Hello World”.

• Both the programs use curly braces to mark the beginning and end of method or class.

• While Java implicitly imports members of the package java.lang into every Java source file, Scala implicitly imports members of the packages java.lang and scala as well as members of the singleton object named Predef into every Scala source file.

The println method call in the Scala example above is actually made on Predef.

• In Java, a public class must be in a file of the same name. In contrast, in Scala, a public class need not necessarily be in a file of the same name. Though, it is thoroughly recommended to have it in a file of the same name just to make it easier for the programmers to locate classes.

• Now, lets try and run the above programs at the command prompt.

Java :

$ javac Main.java
$ java Main
$ Hello World

Scala:

$ scalac Main.scala
$ scala Main
$ Hello World

As we can see, running the programs in the two languages is pretty similar. The output of a java compiler as well as a scala compiler is a Java class file. This class file can then run on the same JVM to produce the output

$ Hello World

1. Install Netbeans 7.2 Beta if not already installed from here.

2. Download the Scala installable from here. Install Scala on your system.

3. Set the environment variable SCALA_HOME pointing it to the Scala installation directory. (On Windows Vista, Go to Start Menu ->Right click on Computer -> Select Properties -> From the left menu, Click on Advanced system Settings -> Click on the Environment variables button on the bottom right corner -> Create new System variable named SCALA_HOME pointing to the Scala installation directory).

4. Now we need to install Scala plugin for Netbeans. Download the plugin here and extract the content into an appropriate folder.

5. Open Netbeans IDE.

6. On the Menu Bar, choose Tools -> Plugin

7. Choose Downloaded tab. Click on Add Plugins button. Browse to the folder containing scala plugins. Choose all the *.nbm files and hit the Install button on the bottom left corner.

5. You need to hit the Next / Continue button and accept the agreements on all the windows that pop up after that.

Plugin auto installs everything.

6. Create New Project. You should now be able to see a new category named Scala. Choose Scala Application. Choose your project name / location and click on Finish. An object named Main which prints out “Hello World” gets created by default. You can run this file as is by hitting Shift+F6 just to check if the environment is correctly set. HelloWorld should get printed as output.

Writing a first Scala program on Netbeans 7.2 seemed a breeze. No headache of conf file changes. But Netbeans 7.2 does seem a lot lot slower than its earlier version 7.0(I have not tried 7.1). Probably because it still is a Beta version.

Following are some gotchas if you are trying to get Scala to work on Netbeans 7.0 or an earlier version of Scala-

1. After installing the plugin, you should be able to create a new Scala project. In case you are not, check if any of the scala plugins are not activated. Select them and activate them.

2. Error message – Could not load definitions from resource scala/tools/ant/antlib.xml. It could not be found.

Solution – Check if Scala has been correctly installed. Append “-J-Dscala.home=scalahomepath” property to the end of “netbeans_default_options” in NetBeansInstallationPath/etc/netbeans.conf where scalahomepath is the actual path to the Scala installation directory.

Please do let me know how your Scala environment setup with Netbeans went. I will be happy to respond to your questions if any. Please feel free to add your comments below.

Adios until the next post !