I have an idea that it may be possible to predict build success/failure based on commit data. Why Scala? It’s a JVM language, has lots of powerful type features, and it has a linear algebra library which I’ll need later.
Project definition and build
Neither maven or the scala build tool (sbt) are completely satisfactory.
This maven **archetype** (what .Net folks would call a VS project template)
mvn archetype:generate `-DarchetypeGroupId=org.scala-tools.archetypes `-DarchetypeArtifactId=scala-archetype-simple `-DremoteRepositories=http://scala-tools.org/repo-releases `-DgroupId=org.SW -DartifactId=BuildBreakPredictor
gets you started right away with “hello world” code, unit tests demonstrating a number of different testing approaches, and even a ready made `.gitignore` file - nice! But the Scala version is behind at v2.8, and more seriously, compiling and testing was painfully slow. So much that a rapid edit – test – edit cycle was not practical. So Lab49 colleague Steve Levine tells me that I can either adjust my pom to use fsc – the fast scala compiler, or use sbt.
Sbt has some nice features
- It’s fast – it uses fsc by default
- It has a continuous mode, so `> ~test` will compile and run your unit test each time you save a file
- It’s can consume (and produce) Maven 2 dependencies
- the build definition file can be much shorter than the equivalent pom (about 1/5 the size, as repos and dependencies can be declared on a single line)
And some real limitations
- Limited support for 3rd party integration – for instance out of the box, TeamCity doesn’t speak sbt, nor does IntelliJ IDEA
- Steeper learning curve for build steps outside the default
Side note: If a language has a fast compiler, why keep the slow compiler around? Even worse, why make it the default?
I choose sbt, for the faster development speed it offers.
Scala APIs really like to use punctuation – sometimes this works well, as in the following
map1 |+| map2
The `|+|` defines a merge operator which does addition on the `values` of the maps.
It’s less useful here:
http(baseUrl / url >- parseJson[BuildStatus]
sure you can probably guess what `>-` does from the context, but how about `>~` or `>+`?
I’m still learning, so not much to say just yet. However case classes are quite usefull, implicits scare me, and type constructors have lots of power.
A number of projects, such as https://github.com/scalala and https://github.com/scalaz/scalaz are split between github and google code – github for the src, and google code for the docs. Not sure I understand the motivation here.