cdb in Erlang

I’ve recently become fascinated by Erlang. I like it’s maturity, scale, and it’s methodology. It’s taken me a couple passes through and Programming Erlang and hours of reading the very well written Erlang docs to become familiar enough to write some simple code.

I’ve decided to implement the constant database, cdbin Erlang. It was a really fun project that required me to,

  • Implement a stand alone library in Erlang
  • Write tests
  • Twiddle bits
  • File I/O

Which I think are some fundamental steps to start understanding a development environment. I’ve released the code as under the MIT License on github.

My Scala Notes

I’ve been working with Scala recently and just wanted to make this post about some tips that I’d like to remember.

Annotating Test Classes
When writing Scala tests, it’s convenient to annotate them such that Eclipse is able to recognize how to execute the test from the “Run” menu. We can enable this by annotating the test class with a @RunWith statement. The IDE unfortunately doesn’t seem to recognize that @RunWith and JUnitRunner are required imports when subsequently performing an “organize imports” operation. As a result, it’s best to specify the fully qualified class name as shown on line two.

 class MyScalaTest extends FunSuite {

Testing Exceptions in scalatest
Below is an example of verifying that code under test throws an exception.

test("throws an exception") {
intercept[Exception] {
throw new Exception("hi")

Working with Eclipse on Windows and Linux Console
I like to use eclipse, emacs, and the console during coding sessions. On my Windows machine I run Eclipse and access the source files over a network drive. This setup requires that my development life cycle be cross-platform compatible. To enable this workflow, it’s convenient for sbt to generate the eclipse project file with all the required dependencies. This is done by adding,

addSbtPlugin("com.typesafe.sbteclipse" % "sbteclipse-plugin" % "2.2.0")

to the plugins.sbt file and running sbt eclipse. Note, the version of the plugin will vary depending on your Scala version. It’s best to visit the project page and try the latest version. Now, it’s also helpful to add the following configuration to your build.sbt file,

// puts library dependencies in the lib_managed directory
retrieveManaged := true

This will download all dependencies to the project directory and the eclipse .project file will be able to reference them locally (as opposed to the ivy repo).

mvn dependency:tree in sbt?
There will come a time when you’ll need to fight through dependency issues. One tool I frequently use is mvn dependency:tree. The equivalent of this command in sbt is enabled by including the following plugin,

addSbtPlugin("net.virtual-void" % "sbt-dependency-graph" % "0.7.4")

and the following to build.sbt,


The dependency tree can be generated by typing,

sbt dependency-tree

See this page for some more info.

Clean implementation of static class instances

Sometimes an application requires a single static instance of a class for the duration of the life of the application. This is typically done by following the Single Design Pattern. One way to demonstrate such an implementation in C# is as follows,

public class Dog {

private static Dog m_Instance = null;

public static Dog Instance {

get {
if (m_Instance == null) {
m_Instance = new Dog();
return m_Instance;

// Dog implementation follows ...

However, can we do better? For instance, what if we have a number of classes which should have a single static instance? We would have to repeat the above code within each class to provide an Instance property. I was recently presented with this exact problem and realized that there is something quite common in the Instance implementation.

In fact, just about the entirety of the code is common except the invocation of the constructor for a particular type. Using generics and reflection we can abstract the Instance property by providing a single abstract class that implements the Instance property for any class type with a default constructor.

The following is a neat implementation of just that.

public abstract class StaticInstance<T> where T : class, new()
private static T instance = null;

public static T Instance
if (instance == null)
instance = Activator.CreateInstance<T>();
return instance;


Now, we can implement Dog as follows,

public class Dog : StaticInstance<Dog> {

public Dog() { ... }

// Dog implementation follows ...


which gives the Dog class the Instance property. Neat!