Well, it shouldn’t be too difficult to connect the points with a slender cylinder, right?

I was wrong, it took me an embarrassingly long time to get the trigonometry right :-)

Here’s my magic crutch:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

public Cylinder createConnection(Point3D origin, Point3D target) {
    Point3D yAxis = new Point3D(0, 1, 0);
    Point3D diff = target.subtract(origin);
    double height = diff.magnitude();

    Point3D mid = target.midpoint(origin);
    Translate moveToMidpoint = new Translate(mid.getX(), mid.getY(), mid.getZ());

    Point3D axisOfRotation = diff.crossProduct(yAxis);
    double angle = Math.acos(diff.normalize().dotProduct(yAxis));
    Rotate rotateAroundCenter = new Rotate(-Math.toDegrees(angle), axisOfRotation);

    Cylinder line = new Cylinder(1, height);

    line.getTransforms().addAll(moveToMidpoint, rotateAroundCenter);

    return line;
}

To illustrate what’s going on, I created a 2D representation of all individual steps, starting off with the creation of the cylinder. By default, its center is placed at the origin:

The moveToMidpoint transformation moves its center to the final location (the yellow midpoint in the above image):

And finally, the rotateAroundCenter transformation corrects the cylinder’s direction:

Obviously, the tricky part is finding the proper axis and angle of rotation. Both are calculated relative to the yAxis because of the cylinder’s initial direction. The axisOfRotation must be perpendicular to the plane defined by the yAxis and the diff vector. To find such a perpendicular vector, we can (by definition) calculate the cross product of the two vectors. In the 2D case, the result is equivalent to the z-axis, but in 3D it may be tilted.

The angle is calculated based on the dot product (aka scalar product) of the two vectors, which is defined by

A • B = |A| |B| cos(alpha)

If A and B are both unit vectors, this becomes

A • B = cos(alpha)

which we can resolve to

alpha = acos(A • B)

That’s it!

Regular expressions allow to parse the date and extract parts thereof¹: (\d\d\d\d)-(\d\d)-(\d\d) defines a pattern which matches the digits and defines capturing groups for the year, month, and day parts.

In Java, a simple example usage would look like this:

1
2
3
4
5
6
7

Pattern pattern = Pattern.compile("(\\d\\d\\d\\d)-(\\d\\d)-(\\d\\d)");
Matcher matcher = pattern.matcher("2015-02-27");
while (matcher.find()) {
    System.out.println("Year: " + matcher.group(1));
    System.out.println("Month: " + matcher.group(2));
    System.out.println("Day: " + matcher.group(3));
}

Accessing the groups by index is rather awkward and error prone. Luckily, Java 7 introduced support for named groups:

1
2
3
4
5
6
7

Pattern pattern = Pattern.compile("(?<year>\\d\\d\\d\\d)-(?<month>\\d\\d)-(?<day>\\d\\d)");
Matcher matcher = pattern.matcher("2015-02-27");
while (matcher.find()) {
    System.out.println("Year: " + matcher.group("year"));
    System.out.println("Month: " + matcher.group("month"));
    System.out.println("Day: " + matcher.group("day"));
}

That’s better, but I personally don’t like how the group names pollute the pattern. Regular expressions are hard to read already, the Java escape characters add yet more clutter, and the additional ?<group> constructs are a kiss of death.

Let’s look at how the same problem can be tackled in Scala:

According to the docs, the canonical way to create a Regex is by using the method r, which is provided implicitly for strings:

1

val Date = """(\d\d\d\d)-(\d\d)-(\d\d)""".r

Note the triple quotes, which allow to use the backslashes without further escaping. While this is nice, the true advantage of Scala is that regular expressions can be used as extractors in a pattern match. The pattern stays plain and simple, and yet we have all the freedom to name groups as we please:

1
2
3
4
5
6

"2015-02-27" match {
  case Date(year, month, day) =>
    println(s"Year: $year")
    println(s"Month: $month")
    println(s"Day: $day")
}

Look ma, no clutter!

The problem with null is not that it was invented back in 1965, but that we are still struggling with it 50 years later. Any Java developer has probably seen and written code like this:

1
2
3
4
5
6
7
8

String result = service.find("id");
String value;
if (result != null) {
    value = result.trim();
} else {
    value = "<absent>";
}
System.out.println("Value: " + value);

In fact, most Java monoglots have probably seen and written code like this so many times, that they don’t even see the problem anymore. And yet, with Java 8, they have to deal with a solution: the Optional type.

I recently came across this popular article: Embracing the Void: 6 Refined Tricks for Dealing with Nulls in Java. It gives a nice rundown of strategies around the null reference. Sadly, it discourages the use of Java 8’s Optional. In this post I will explain why the argumentation is flawed.

Types to the rescue

One way to re-write the above snippet using Optional could look like this:

1
2
3
4
5
6
7
8

Optional<String> result = service.find("id");
String value;
if (result.isPresent()) {
    value = result.get().trim();
} else {
    value = "<absent>";
}
System.out.println("Value: " + value);

The service returns an Optional<String> and the caller is working her way around it. From a complexity point of view, the change is argueably not much of an improvement: We still need a mutable value variable, and the overall logic is roughly the same. And yet, the expressiveness has improved. The signature of the service has clearer semantics now. Originally, the caller of the service could not distinguish between “the implementor of the service made a programming error” and “the value has not been found” – both were resulting in null. This is possible now and – even better – the type system forces the caller to deal with absents values.

But wait, there’s more

Now that the semantics are straight, let’s make the value variable immutable and eliminate the if .. else construct:

1
2

Optional<String> result = service.find("id");
final String value = result.orElseGet(() -> "<absent>").trim();

This code is safer, more expressive, and more concise than the original version, but the () -> "..." clutter makes my Scala heart cringe, so I’m offering yet another variant:

1
2

Optional<String> result = service.find("id");
String value = result.map(String::trim).orElse("<absent>");

We are taking advantage of the fact that Optional behaves like a collection: If it is absent, it behaves like an empty list, the call to map is never executed, and the result is an empty Optional (which we handle via orElse). If the result is present, it behaves like a list with one element, which we trim and return.

Wrapping legacy code

Imagine that our original service interface is actually coming from a 3rd party library. You can’t simply change all the signatures to properly return Option<T>. But you can wrap the service calls and create yourself a null-safe world:

1

Optional<String> result = Optional.ofNullable(legacyService.find("id"));

Unboxing a cat in a box in a box

And finally: The holy grail of functional programming, flatMap.

Let’s start with a simple User which has an optional middle name:

1
2
3
4

interface User {
    String getName();
    Option<String> getMiddleName();
}

Looking up the user via service is straightforward, but look at all those types:

1
2

Optional<User> result = service.find("id");
Optional<Optional<String>> middleName = result.map(User::getMiddleName);

The outer Optional is the result of the map call (presence/absence of User), while the inner Optional is wrapping the middle name value.

flatMap is our power tool to unwrap the value from nested Optionals:

1

String middleName = result.flatMap(User::getMiddleName).orElse("Ada");

So next time you can’t remember the semantics of flatMap, just think of all those cats stuck in their nested boxes:

(via @channingwalton)

I highly recommend The Neophyte’s Guide to Scala - Part 5: The Option Type for anyone interested in further details.

Hilary is coding in Python, but I took her excellent examples as an inspiration to further practice my Scala. Based on Breeze, a set of libraries for machine learning and numerical computing, I wrote my first little classifier.

My classifier uses a support vector machine (SVM) to distinguish images of two distinct categories — one containing circles, the other containing crosses. I used 10 different fonts to create the two sets of test images:

I used the red component of each pixel’s RGB value as a feature vector. Given that all images are in grey scale, this seemed like a good first choice. And indeed, after training the SVM with 9 images of each category, the 10th image can be classified with a probability of roughly 0.75.

All code can be found on GitHub.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

abstract class Carnivore {

  def eat: Carnivore = {
    println("eating meat, yummy!")
    this
  }

}

class Dog extends Carnivore {

  def bark: Dog = {
    println("wuff!")
    this
  }

}

For obvious reasons, the compiler will only allow to chain methods in a certain order:

1
2
3
4
5

val dog = new Dog()
// compiles ok
dog.bark.eat
// does not compile ('eat' returns a Carnivore, which cannot bark)
dog.eat.bark

In the Java world, possible work-arounds involve generics. Either via overriding, or with a self-reference trick. Here’s how it would look in Scala:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

abstract class Carnivore[T] {

  def eat: T = {
    println("eating meat, yummy!")
    self
  }

  abstract def self: T

}

class Dog extends Carnivore[Dog] {

  def bark: Dog = {
    println("wuff!")
    this
  }

  def self = this

}

While this works just fine, it involves quite some clutter. And Scala can actually do better! A powerful (but yet not very well-known) construct can solve the problem: this.type

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

abstract class Carnivore {

  def eat: this.type = {
    println("eating meat, yummy!")
    this
  }

}

class Dog extends Carnivore {

  def bark: Dog = {
    println("wuff!")
    this
  }

}

And now go spread the word!

Due to the official code of honour, I am not allowed to discuss any actual code here, but the last assignment is still worth mentioning: Based on the concept of lazy data structures, we were asked to find a generic solution to the Bloxorz game. When I initially read the assignment, I doubted that this would be possible within a reasonable amount of time. But the exercises were so well crafted, that they guided us in a step-by-step fashion – in the end, I managed to get the maximal score within less than two hours.

Inspired by the addictive block-rolling, I was recently playing around with CSS3. I really have no 3D experience whatsoever, but here’s my quick shot at some basic transformations (webkit only; put focus on cube and press left/right arrows):

Both of them are very much based on conventions, i.e. they require only minimal configuration if you stick to the rules of a default project structure. But what is the default project structure? And how can you set one up with minimal effort?

Enter giter8: A command line tool to generate files and directories from templates published on github.

For sbt:

The official sbt templates maintained by Typesafe can be found here (note that they publish g8 templates for their complete stack, even for examples & tutorials).

For Gradle:

There’s no official Gradle counterpart, but https://github.com/coacoas/scala-gradle.g8 works like a charm.

As usual, just fork & improve if you need the templates to behave differently.

Afaik, it’s still not too late to register, and it’s FREE: http://www.coursera.org/course/progfun

Regarding tool setup: Don’t even download the Eclipse-based Scala IDE, it sucks big time. How can these people get anything done with a piece of crap that crashes every few minutes, even with just a 2-file project?! Luckily, the assignments can as well be completed with IntelliJ IDEA, with the community edition Scala plugin.

To end this post with some code, this is how the first exercise looks like:

1

def pascal(c: Int, r: Int): Int = ???

The cool thing is that this code compiles – Scala method naming FTW!

Here’s how I changed the default (blue) icon to the new (pink) one:

First, reveal the application’s installation location in Finder (from the Dock context menu: Options » Show in Finder). From within Finder, invoke the context menu on the selected application, and Show Package Contents. Locate the icon file (*.icns) inside Contents » Resources. Make a backup copy, edit the icon in your favorite image editor (I simply overlaid a red color filter in Acorn), and save it as a *.png.

Now comes the tricky part: Apple’s icon format includes more than just an image, it actually contains a collection of images in different sizes, resolutions & states. To create a new *.icns file, launch Icon Composer (which ships with OSX). Open the original application icon to check which sizes your new icon should support:

Create a new file, drag & drop your edited *.png to the required image size containers, and save the result. Re-launch your application – tada!

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

on run dir
  tell application "iTerm"
    activate
    tell last terminal
      set mysession to (make new session at the beginning of sessions)
      tell mysession
        set name to "Default"
        exec command "/bin/bash -l"
      end tell
      tell mysession
        write text "cd " & dir
      end tell
    end tell
  end tell
end run

IDEA allows to add custom actions via Settings » External Tools. Save the above script to a file (e.g. launchTerminalAndChangeDir.scpt) and configure a new Reveal in Terminal action as follows:

Additionally, you may want to associate a key binding via Settings » Keymap. I chose Ctrl-Shift-T, which seems intuitive and is not conflicting with any OSX defaults.

Setting up the new machine was certainly an opportunity to consolidate the apps and tools I like and need. Inspired by The Setup, here’s what I currently use to get things done:

As a Java developer, I spend most of my time in IntelliJ IDEA, the best IDE ever (weight this statement by the fact that I used Eclipse for 7+ years before). My second home is the command line. I use iTerm2, which has excellent search support, provides mouseless copying, and is more unixy than the official Terminal. I’m still learning to use _ Finder efficiently. The TotalFinder plug-in, with tab support and its Folders on Top_ mode, is my latest attempt at making friends.

A few crucial things help me organize & navigate my workspace: I use three virtual desktops (via Mission Control) which I access by keyboard shortcuts – 1 for Mail/Calendar, 2 for Browser, and 3 for IDEA. A launcher helps me kick-start applications. I switched from Quicksilver to Alfred – it provides the same features and is under active development. Divvy tames all window sizes & positions, clearly a missing feature in OSX.

Transitioning from Snow Leopard to Lion was more challenging than anticipated, mainly because of its different mouse usage paradigms. Most of the built-in gestures are easy to use, but some of them collide with my old habits (how the heck can I turn off horizontal scrolling in order to re-map the swipe gesture to back/forward navigation in IDEA?!). A while back I forced myself to exclusively use taps (rather than clicks) on the trackpad. Wow – the absence of the mechanical noise makes such a difference, everything suddenly feels very light and smooth!

These are pretty much the apps at the core. In addition, I like Chrome, 1Password, TextMate, Dropbox, Skype, Spotify, Acorn, Inkscape, Lightroom and OmniGraffle – just to name a few.

What are your favorite tools we should all know about?

What HTML would have been had it been designed for web apps.

All I can say after a few hours: HTML would haven been great! It would have had a clear MVC separation, data binding, dependency-injection, and it would have kept development simple & fun.

My web app know-how is very rusty, so I hacked together a simple proof-of-concept, just to see how AngularJS actually feels. Here are the crucial snippets from my Google App Engine Java back-end (to generate JSON), and the HTML/AngularJS view (to render it).

The Servlet part:

1
2
3
4
5
6
7
8

protected void doGet(...) {
  response.setContentType("text/plain");
  String[] movies = new String[]{
    "Buffalo 66",
    "Jackie Brown",
    "Vicky Cristina Barcelona"};
  response.getWriter().print(new Gson().toJson(movies));
}

The AngularJS Controller:

1
2
3
4
5
6
7
8

function MovieListCtrl($xhr) {
  var self = this;
  $xhr('GET', 'http://localhost:8080/json',
    function(code, response) {
      self.movies = response;
    }
  );
}

The HTML/AngularJS View:

1
2
3
4
5
6
7
8

<body ng:controller="MovieListCtrl">
  Rahel's favorite movies:
  <ul>
    <li ng:repeat="movie in movies">
      {movie}
    </li>
  </ul>
</body>

Check out the official AngularJS Tutorial for more details and a ton of cool examples.

1
2
3

println(Array.fill(7, 3)("X").map(
  _.mkString("\t")).mkString("\n")
)

Is it readable? No. Is it handy? Yes!

1

MigrosEgg(GREEN, BLUE)

Unless you’re Swiss and just know that I’m referring to the “Extra” variant, wouldn’t it be a lot less ambiguous to write

1

val aMigrosEgg = MigrosEgg(dotColor = GREEN, bgColor = BLUE)

As of Scala 2.8 you can name your arguments. You can also leave out those which have default values, shuffle their order – or you can simply have another one of those little suckers:

1

val notAMigrosEgg = aMigrosEgg.copy(dotColor = PINK)

Happy easter everyone!

1
2
3
4
5
6
7
8

def reveal = {
  if (revealed == false) {
    revealed = true
    if (adjacentMineCount == 0) {
      adjacentCells.foreach (cell => cell.reveal)
    }
  }
}

In summary: 1 usage of => (and even a recursion ;-)).

Life as a Java programmer had gotten harder over the last few years. Not that I don’t enjoy my job anymore, to the contrary, but reading about all these highly dynamic youngsters hacking together their Python/Ruby/Groovy wizardy at the speed of light has made me feel even older than I already am. Old-fashionedness at its finest: I absolutely can’t relate to all this enthusiasm for dynamic languages. Ok, I admit that some script-fu will certainly help getting this nasty little problem solved quickly, but how the heck will a huge Rails project be maintainable over 10+ years? Or do we still have to wait longer for time to tell that it will fail? Do these people write tests for each and every thing that otherwise would be checked by a compiler? Isn’t this a rather high price for a little duck-typing?

I am obviously being cynical, but luckily I am not the only one in doubt. Some great brains also think that throwing away the type system is not the best compromise to make in order to get rid of Java’s (admittedly extensive) boilerplate. In this excellent talk, Bill Venners speaks about his preference for typed languages. He mentions “deterministic refactoring” as the main benefit, which he explains like this:

I don’t like types because I think they proof my program correct […] but because they can proof changes that I make to my programs are correct

Coming back to Scala: It seems to combine the best of all worlds – strictly typed, functional & object-oriented, radically concise, and just close enough to the Java world for old-timers to transition gradually ;-)

To keep my new Scala heart beating, I will start posting weekly Scala gems. Let me start with the example given in the above interview – just to illustrate what “no boilerplate” and “concise” really mean. In Java:

1
2
3
4
5
6
7
8
9
10
11
12
13

public class HowdyClass {

    private String name;

    public HowdyClass(String name) {
        this.name = name;
    }


    public String sayHowdy() {
        return "Howdy " + name;
    }
}

and in Scala:

1
2
3

class HowdyClass(name: String) {
    def sayHowdy = "Howdy " + name
}

The following example is my personal highlight after roughly two hours of playing around with the interpreter: Initializing a two-dimensional grid with indexed cells:

1
2

class Cell(x: Int, y: Int)
Seq.tabulate(3, 9)(new Cell(_, _))

This is actually almost too concise (or at least as a functional noob it took me quite some time to understand it). Here’s a verbose equivalent which is a bit more self explanatory:

1

Seq.tabulate(3, 9)((x: Int, y: Int) => new Cell(x, y))

And now go get it and have a lot of fun!