Neil’s point-free blog

Scala is really hot at the moment – even the Java Posse lads are talking about it! Scala seems to provide the ideal pragmatic mixture between functional programming and interoperability with Java.

So I wondered if it was possible to build an OSGi bundle with it, and if so whether there would be any benefit in doing so. As it happens, yes you can, and yes there is!

Unfortunately you can’t use Eclipse PDE (Plug-in Development Environment) at the moment for this. Even though there’s a reasonable Scala plug-in available for Eclipse, it doesn’t integrate with PDE properly. I did try creating a Scala project (which is basically just a Java project with an extra “nature” and builder), and then adding the PDE nature to it (using PDE Tools -> Convert Projects to Plug-in Projects…). But PDE removed the Scala plug-in’s special classpath container, and then the Scala builder barfed.

So here’s a simple tutorial, in the style of my “Getting Started” OSGi tutorial on EclipseZone, but this time we’re going to build the bundle in Scala. What we want is a bundle that, when activated, will print a list of currently installed bundles.

package scalaosgi;

import org.osgi.framework._

class Activator extends BundleActivator {
    def start(context: BundleContext) {
        var bundleNames = context.getBundles()
                 .map   (b => b.getSymbolicName())
                 .filter(b => b != context.getBundle());
        Console.printf("Installed bundles: {0}",
                        bundleNames.toString());
    }

    def stop(context: BundleContext) {
    } 
}

We can see several interesting things from this code sample. Firstly, it’s trivial to implement a Java interface or extend a Java class using Scala. Here we’re implementing the OSGi BundleActivator interface. The most interesting part though is the first line inside the start method, which illustrates three really cool functional programming features all in one line: type inference, higher-order functions, and lambda abstraction.

Type inference means we didn’t have to explicitly state the type of the bundleNames variable - the compiler is able to work it out for us, so we only have to say “var“.

A higher-order function takes a function as one of its parameters. In Scala, functions are objects, so they can be easily passed into functions as parameters or returned as results. The higher-order function here is “map”, which is used to map a function over each entry in a list or array and returns a new list or array containing the results of that function.

A lambda abstraction is simply an anonymous function, which in Scala is indicated with the => syntax. Here our lambda is (b => b.getSymbolicName()), i.e. a function which takes an object and returns the result of calling the getSymbolicName() method on that object.

The result of all this is a very concise line of code which would probably have to be done like this in Java:

    Bundle[] bundles = context.getBundles();
    String[] names = new String[bundles.length];

    for (int i = 0; i < bundles.length; i++) {
        names[i] = bundles[i].getSymbolicName();
    }

Okay, this isn’t such a terrible piece of Java code, but to a functional programmer it looks like mostly boilerplate. It also doesn’t compose very easily. In the Scala example we could easily add a filter to remove our own bundle from the output:

var bundleNames = context.getBundles()
                  .filter (b => b != context.getBundle())
                  .map    (b => b.getSymbolicName());

In Java we would have to do this with an if block inside the for loop.

Anyway how to we compile and run this? As in the “Getting Started” series, I’ll assume you’ve taken a copy of the Equinox OSGi runtime as equinox.jar. See the first installment of the series for instructions if this is not clear.

After copying the above Scala class into a file, scalaosgi/activator.scala, we can compile it with the command:

scalac -classpath equinox.jar scalaosgi/activator.scala

Now we need a Manifest, so copy this into scalatest1.mf:

Manifest-Version: 1.0
Bundle-Name: Scala Hello
Bundle-Activator: scalaosgi.Activator
Bundle-SymbolicName: ScalaHello
Bundle-Version: 1.0.0
Import-Package: org.osgi.framework, scala, scala.runtime

Remember, the final blank line is vital! Now build the JAR with:

jar cfm scalatest1.jar scalatest1.mf scalaosgi/*.class

We’re also going to need a “bundle-ized” (or “OSGified”) version of the Scala library. That can easily be created using the “Plug-in from Jar” wizard in Eclipse, but to save you some hassle I have prepared a Manifest file that can simply be injected into the existing Scala library jar. To do this, take a COPY of scala-library.jar into the current directory, and also download the manifest file at http://neilbartlett.name/downloads/scalaosgi.manifest. Then run the command:

jar ufm scala-library.jar scalaosgi.manifest

Finally we’re ready to launch Equinox and test our code:

$ java -jar equinox.jar -console

osgi> install file:scalatest1.jar
Bundle id is 1

osgi> install file:scala-library.jar
Bundle id is 2

osgi> start 1
Installed bundles: Array(org.eclipse.osgi,ScalaHello,
         scala_library)

That’s it for the moment. I’ve only just started learning Scala so there are probably some newbie mistakes and stylistic oddities in what I’ve done.

My first impressions of Scala? Pretty good! It has nowhere near the power and elegance of Haskell, but it’s a big improvement on Java.