We just got back from a two-week trip to Japan, which was simply amazing. I’ve seen more temples and Torii gates than I care to remember; I’ve seen the spring festival of Takayama and the Peace Museum of Hiroshima. We went on a pilgrimage to Akihabara, shopped at Super Potato, and had drinks at 8-bit Cafe.

As most of my Japan knowledge comes from exclusively from playing the Yakuza games, one of my personal highlights was visiting the real-life “Kamurocho” and seeing the iconic Kabukicho gate.

Side note: Tokyo is about just about the only city on earth where I’d feel comfortable walking around the red light district at night snapping pictures with my big touristy camera.

“Troy,” I said, “the reason I want so much to play this game is because nobody wants me to play this game. There is virtually no person you could present this to without getting a stunned, pitying look in return, and that ticks me off. It ticks me off because what so freaks people out is the time involved in this endeavor, time. Everything in adult life is designed to steal it away from us, and my God, look how we go along with the scheme so willingly.

“‘I have no time for such things anymore,’ we say, and then we spend our afternoons making our lawns pretty and shopping for junky Ikea furniture and ferrying kids to soccer games and gawking at cable TV, and above all, working at jobs we never really wanted. ‘Sure,’ we say, ‘when I was young and didn’t have all these responsibilities, I could spend hours doing this kind of thing. But that was then, and this is now.’

“Well, Troy,” I went on, “I want to be the guy who suddenly, at age 42, does spend hours doing this kind of thing, if only to feel what it’s like to take back a little piece of the soul I’ve sold to the company I slave for, to the obligatory evenings with people I’m not sure I even like, to daily errands, the lines at the DMV, to tax forms, to tedious family visits. This game is a slap in the face to all thinking creatures who live in such dire fear of the sands sifting through the hourglass. Playing a monster war game on this scale is ridiculous, a waste of energy, a waste of time, and so I want to do it. Let spite rule the day, Troy. Let’s learn and play A World at War!”

You know, because I can.

(I promised @nicferrier a writeup on this project, so here goes.)

Installing Emacs 24

The Emacs that comes with the Raspian distribution is version 23.4. Unfortunately, elnode requires Emacs 24, so I had to compile my own. I dreaded doing this, but it actually turned out pretty straightforward.

You need to apt-get install some build dependencies like libncurses-dev (and probably build-essentials if you don’t already have them), then you’re ready to go:

1
2
3
4
5
6

 > wget http://ftp.gnu.org/pub/gnu/emacs/emacs-24.2.tar.gz
 > tar xvfz emacs-24.2.tar.gz
 > cd emacs-24.2
 > ./configure
 > make 
 > sudo make install

This would be a good opportunity to make a sandwich, or learn some sanskrit, as building everything will take quite a while.

Running Emacs

By default the elnode webserver runs on Emacs startup, so the idea is to fire up emacs and just leave it. One way of doing that would be to ssh into the Pi and run emacs inside a tmux session (I tend to use tmux for all remote access anyway). This makes the emacs process persistent, and when I next log in I can just resume the session.

However, with this approach I’d still need to login in and start manually every time the server restarts, so the setup is kind of fragile. Especially since I have builders running round the house cutting the main power every now and then.

So instead I use a simple init script to run emacs in daemon mode (using the aptly named --daemon switch). This way I can still connect to the running emacs process using emacsclient, but I don’t have to bother with starting it manually anymore.

The only caveat is that since I want start-stop-daemon to fork off a new process to run emacs as the pi user (running a web-connected emacs as root seems like a really bad idea), I can’t rely on it to generate a correct PID file for me. Instead, we’ll have to do that from inside emacs (see next section).

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

#!/bin/sh

set -e

# Must be a valid filename
NAME=elnode
PIDFILE=/home/pi/elnode/elnode.pid
UID=1000
#This is the command to be run, give the full pathname
DAEMON=/usr/local/bin/emacs
DAEMON_OPTS="--daemon --load /home/pi/.emacs.d/init.el --load /home/pi/elnode/web.el"

export PATH="${PATH:+$PATH:}/usr/sbin:/sbin"

case "$1" in
    start)
        echo -n "Starting daemon: "$NAME
        start-stop-daemon --start --quiet --pidfile $PIDFILE --chuid $UID --exec $DAEMON -- $DAEMON_OPTS
        echo "."
      ;;
    stop)
        echo -n "Stopping daemon: "$NAME
        start-stop-daemon --stop --quiet --oknodo --pidfile $PIDFILE
        echo "."
      ;;
    restart)
        echo -n "Restarting daemon: "$NAME
        start-stop-daemon --stop --quiet --oknodo --retry 30 --pidfile $PIDFILE
        start-stop-daemon --start --quiet --pidfile $PIDFILE --chuid $UID --exec $DAEMON -- $DAEMON_OPTS
      echo "."
      ;;

    *)
      echo "Usage: "$1" {start|stop|restart}"
      exit 1
esac

exit 0

When I start the deamon I get some weird error messages from elnode, but as far as I can tell it actually runs fine.

1
2
3
4
5
6
7
8

pi@raspberrypi ~ $ sudo /etc/init.d/elnode start                                                                                                                  
Restarting daemon: elnode("/usr/local/bin/emacs" "--load" "/home/pi/.emacs.d/init.el" "--load" "/home/pi/elnode/web.el")
Starting Emacs daemon.
deleting server process
elnode-error: elnode--sentinel 'deleted.' for process  *elnode-webserver-proc* with buffer *elnode-webserver*
found the server process - NOT deleting
elnode-error: Elnode server stopped
.

Running elnode

Elnode is available from Marmalade, which makes it very easy to install from inside emacs. I also grapped the xmlgen library to help with HTML generation.

This is my little Hello World-script. There’s nothing remarkable about it, really. The first section generates a PID file to be used by the init script to check if the process is running. I stop the default server, as it binds to “localhost”, and I want to bind to the actual server name (raspberrypi.local in my case) in order to serve remote requests. You can see it in action here.

Did I say there was nothing remarkable about this script? Yeah, apart from the fact that it’s running a webserver inside a 25 year old text editor on a computer that’s about as large as a deck of cards.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38

;;; -*- lexical-binding: t -*-

;; write the pid file
(with-temp-file "/home/pi/elnode/elnode.pid" (insert (format "%d" (emacs-pid))))

(require 'cl)

;; stop the default server
(elnode-stop 8000)

(defvar request-count 0)

(defun hello-handler (httpconn)
  "Hello, world"
  (elnode-http-start httpconn 200 '("Content-Type" . "text/html"))
  (elnode-http-return httpconn
            (xmlgen
             `(html
           (head
            (title "Hello, elnode!")
            (style "body { margin:100px auto auto auto; width: 400px; }"))
           (body
            (p "Hello, I am a small "
               (a :href "https://github.com/nicferrier/elnode" "webserver")
               " running inside Emacs 24 on a "
               (a :href "http://www.raspberrypi.org" "Raspberry Pi")
               ".")
            (p "The local time is "
               ,(format-time-string "%H:%M")
               " and I have served a total of "
               ,(incf request-count)
               " requests."))))))

(defun root-handler (httpconn)
  (elnode-hostpath-dispatcher httpconn '((".*/favicon.ico" . elnode-send-404)
                   (".*" . hello-handler))))

(elnode-start 'root-handler :port 8000 :host "raspberrypi.local")

Java is… well, it’s Java. For all it warts, it’s actually a pretty decent environment to get things done in. Yeah, it’s verbose as hell. Yeah, most projects involve heaps of boilerplate XML. And yeah, Maven is still the best we’ve got. But still, when you know your way around it’s not bad. The 3rd party library support is outstanding, and most of it is Open Source. Performance is generally good. And the cross-platform compatibility is at this point something we just take for granted.

There have been other languages. I was heavily into Common Lisp for a while. I would prefer it over java were it not for the lack of standard libraries. Clojure seemed like a logical progression, but for some reason I couldn’t get into it. I love the premise: “Functional programming with full access to the Java ecosystem,” but for some reason I never stuck around.

I was on the Scala wagon, I know enough Ruby to be dangerous, and I’ve flirted with Go, Haskell, Python, and CoffeeScript. All excellent languages in their own right. None of them really stuck. I’ve read the books, the blogs, the twitters. I know these are the languages the cool kids use nowadays. Maybe it was me, maybe I wasn’t hipster enough.

But there is one language that has grown on me. That hasn’t gone away or been replaced. It’s a ugly little thing, full of warts and cruft that has accumulated over many years. It is a Lisp, but it’s awkward and eccentric even by Lisp standards. It lacks basic necessities like namespaces and, for the longest time, lexical scoping. The standard library is confused and naming conventions are all over the place. Many Common Lisp staples (like loop, map, and reduce) are missing. There is a Common Lisp compatibility package, but using it was controversial and for a long time actively discouraged.

I am, of course, talking about emacs lisp. I took stock of my github projects and realized that apart from the Java stuff, almost all of my recent activities are elisp. This was not something I had planned, it’s just that Emacs is such an awesome elisp IDE. I’m more productive in elisp than in any other environment. When I make code changes I’m not just connecting to a REPL, I’m actually changing the very environment I’m currently coding in. This is incredibly powerful.

So, Java and elisp. Not very cool, I know. But do not underestimate the power of knowing your tools and getting shit done.

I happened to attend a technical session, mostly because there was nothing better on. Gerrit Grunwald showed off a Pi-based system he had set up to display the temperature in his home, and I was sold immediatly. As I left the room I flipped open my laptop, found a reseller and ordered myself a starter kit. A few hours later I got a notice saying it had shipped and by early afternoon the next day it had been delivered, a full two days before I got home myself.

These are my impressions after playing with it over the weekend:

• It really is small. Really, really small. Of course, I seem to have a thing for small computers.
• Video output is strictly HDMI. It hooked up to the TV and booted nicely, but when I tried connecting it to my old 17” monitor using a HDMI-DVI converter I couldn’t get any signal at all. It doesn’t really matter all that much, as getting a SSH server up and running was trivial, and I kind of prefer accessing it through the network anyway.
• I had the notion that Go would be a good language to do some systems programming in, but getting the infrastructure in place was not trivial. Essentially you have to apply a small patch and rebuild the debian packages before installing, and remember to put export GOARM=5 in your .bashrc.
• The CPU isn’t great. Building Go from scratch took me well over 30 minutes. I realize I may have been spoiled by my MacBook.

And now I have a trivial webserver running:

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

package main

import (
  "fmt"
  "net/http"
  "html"
  "log"
  )

var port = 8001

var s = &http.Server {
  Addr: fmt.Sprintf(":%d", port),
}

func main() {
  http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
      fmt.Fprintf(w, "Hullo, %q", html.EscapeString(r.URL.Path))
  })
  log.Printf("starting web server on port %d", port)
  log.Fatal(s.ListenAndServe())
}

Pretty hard, as it turns out. The ZSH completion system is ridiculously complex and poorly documented. There is a pretty good ebook, but it is from 2003 and I’m sure a lot of things have changed since then. Other than that, then only tutorial on writing your own completion functions was an old Linux Mag article.

After a lot of trial and error, borrowing code from various oh-my-zsh plugins, and nearly giving up in frustration, I’ve now produced a plugin of my own. It’s pretty large (1147 lines), but has completions for all the 265 subcommands that I know of. I quickly realized that maintaining the argument completions for all these subcommands would be quite impractical, so I did what any hacker would do: I wrote quick-and-dirty program that goes through all the glassfish jar files on the classpath, looking for classes that implement the asadmin commands. It then looks at annotations and uses a bit of introspection to determine what arguments are available for each command, and what completions (if any) should be used to complete these. The end result is a ZSH script fragment which I then insert manually into my completion script. Overall, this has worked out pretty well. And it sure beats doing it by hand.

Anyway, if you work with asadmin and would like some hot completion action going, check out my oh-my-zsh branch on github.

Even better, I made two releases, both at the same time. Thing is, the eclim guys switched the format of the response messages to JSON with eclim 1.7.3. That was a rather good change, but it meant we had to do quite a bit of work on our end to get everything working properly. And that’s why it finally made sense to start talking about emacs-eclim releases. If you are stuck on an older version of eclim, you need emacs-eclim version 0.1; but for eclim 1.7.3 or later you must run emacs-eclim 0.2, or HEAD.

First, since we want headings in the source code to stand out, we’ll define a new font face, based on font-lock-preprocessor-face. It could be inherited from any face, really, but let’s pick one that’s likely to have been included in most colour themes.

1
2
3
4

(defface inform7-heading-face
  '((t (:inherit font-lock-preprocessor-face :weight bold :height 1.2)))
  "Face for Inform 7 headings"
  :group 'font-lock-highlighting-faces)

Then some keybindings for our mode. There’s not much for us to do here, but let’s make RET automatically jump to the correct indentation level; that’s always nice:

1
2
3
4
5
6

(defvar inform7-mode-map
  (let ((map (make-sparse-keymap)))
    (define-key map (kbd "RET") 'newline-and-indent)
    (define-key map "\C-j" 'newline-and-indent)
    map)
  "Keymap for inform7 major mode")

The easiest way to add syntax highlighting for our mode is to use regexp-based matchers. Inform 7 hasn’t got that much of a formal syntax, but it would be nice to highlight keywords like if, then and otherwise and for section headings in the text. We should also find some way of supporting indexed text (i.e. anthing inside a string surrounded by []).

The last one is a bit tricky, as the same delimiters are also used for comments (see below), and it’s not actually possible to distinguishing between them using only regexps. The solution here, prepending a ‘.’ to the matcher, is a workaround that’s good enough for most cases though.

One thing to watch out for is that that the names of the faces must be symbols. For the built-in faces there are variables defined for each of these, but we must be careful to quote the name of the face we defined above.

1
2
3
4
5
6

(defconst inform7-font-lock-keywords
  `(( ,(regexp-opt '("Include" "Use" "let" "say" "if" "otherwise") 'words) . font-lock-keyword-face)
    ("^\\(\\(?:Book\\|Chapter\\|Part\\|Section\\|Volume\\) - .*\\)" . 'inform7-heading-face)
    (".\\(\\[.*?\\]\\)." 0 font-lock-variable-name-face t)
    )
  "Highlighting expressions for inform7-mode")

We now have everything we need to define our new mode. Current wisdom holds that it’s a good idea to extend an existing mode using define-derived-mode, and have someone else do all the heavy lifting. In our case, we want to extend sws-mode, which handles significant whitespace and provides functions for intelligent indentation of lines and blocks of code. It is part of jade-mode.

Defining our major mode is deceptively simple; we just pass in a mode name, the name of the mode we’re deriving from, a printable name that will be displayed in the status line, and a body of code that will be executed when the mode is initialized. define-derived-mode will take care of the rest and set up a keymap, syntax table, mode hooks and ensure that the parent mode and the hooks are called on init. In our case, we’ve already created the keymap manually, so define-derived-mode will use that one instead.

1
2
3
4

(define-derived-mode inform7-mode sws-mode "Inform7"
  "Major mode for editing inform 7 story files."
  (visual-line-mode)
  (set (make-local-variable 'font-lock-defaults) '(inform7-font-lock-keywords nil t)))

Two things remain, though. First, the line indent function does always increases the indentation of new/empty lines by one step. For inform code, we only want that if the preceding line ends with a ‘:’, otherwise we’d like the new line to have the same indentation level as the previous one.

It turns out, that can be accomplished by adding some advice around sws-do-indent-line, which is the function in sws-mode that actually carries out the indentation:

1
2
3
4
5
6
7
8
9

(defadvice sws-do-indent-line (around inform7-indent-blank () activate)
  "Ensure proper indentation of blank lines according to Inform7 conventions."
  (if (and (eq major-mode 'inform7-mode) (sws-empty-line-p))
    (if (save-excursion
          (previous-line)
          (looking-at "^.*:[ \t]*$"))
        (indent-to (sws-max-indent))
      (indent-to (sws-previous-indentation)))
    ad-do-it))

The other thing we need to fix is highlighting of comments in the text. We don’t want to do this with regexps, as it’s tricky to get this working reliably for multi-line comments. Instead, we’ll take advantage of the built-in facilities for syntactic highlighting. Incidentally, you may have noticed that we didn’t have to do anything to get highlighting of strings in the code; the syntactic parser gives us that functionality for free.

These two lines modifies the syntax table, telling the parser to treat [ and ] as comment delimiters.

1
2

(modify-syntax-entry ?\[ "<]" inform7-mode-syntax-table)
(modify-syntax-entry ?\] ">[" inform7-mode-syntax-table)

So there we are, 41 lines of code all in all, not bad for a start.

There seemed to be a good deal of interest in Scala at the event, but I’m not sure this actually reflects some kind of actual change in the Java ecosphere. Mostly, it were small, hip, consultancies doing the promotion, and I have a gnawing suspicion that they don’t have much Scala work lined up per se, but are instead using Scala to get the attention of potential recruits. Time will tell.

I’m a pretty introverted guy, and don’t really feel that comfortable around a lot of people. Most of the time during the big breaks I found myself wishing for a laptop so that I could get hacking instead of having to wander round aimlessly pretending to feel at home in the crowd. Fate, however, seated me beside Chris Richardson (of Cloud Foundry fame) during lunch the first day, and we had a pretty good discussion, even though my english was still getting up to speed. For some reason I also managed to corner Greg Luck during the tuesday bar and talk to him about Ehcache. Both were very nice guys, and I’d like to thank them both for helping me come out of my shell a bit.

Like most java programmers, I was a long-time eclipse victim. If you’re not from the java world yourself, it might be hard to grasp the love/hate relationship that all java programmers have with this IDE. Or hate/hate relationship, as it may be. Sure, some people turn to NetBeans or IntelliJ, but you can’t get away from the fact that eclipse has in essence steamrolled all over the java IDE space. Eclipse is everywhere.

Incidentally, ‘steamrolled’ is an appropriate word here, as it suggests huge mass and inertia bordering on inevitability, both of which are also properties of eclipse itself. It takes forever to start up, and if you actually manage to kick off a complex build operation, it’s impossible to interrupt it.

Emacs was my escape. But the story is kind of complicated. You see, there was this bunch of enterprising vim hackers that realized that even though their editor was the greatest thing since sliced bread, it wasn’t really that good at handling large java codebases, something which eclipse is atually pretty competent at. So they wrote a plugin for eclipse that turned it into a kind of server, and a vim extension that acted as a client, and then they could edit the code in vim, while leveraging the strengths of eclipse, such as command completion, compilation, and refactoring. And they called it eclim.

Then another enterprising fellow ported the client libraries to emacs, and the result was emacs-eclim. It was a bit rough at first, but it is improving steadily. In the past year, we’ve gotten auto-complete-mode support, inline error highlighting, improved handling of import statements and numerous bug fixes. Right now I’m working on making calls to the eclimd backend asynchronous, to make editing more responsive. It kind of works, but right now it’s ugly.

I actually have no idea how many users we have. There are 116 people watching the project on Github right now, and bug reports are being filed every now and then, so I’d like to think that at least someone finds it worthwhile.

This is the first time, however, that I actually had to reflect on my working conditions as a remote worker. I have a home office set up, complete with a stand-up desk, a Fatboy bean bag, and multi-function printer. I do the lion part of my work on my laptop, hooked up to the compay VPN. Inter-team communication is done using Campfire and daily telephone meetings. In many ways, this is just like working at the office, except a) I can blast whatever I want on the stereo, and b) I don’t get dragged into meetings as often as I used to.

Working alone does mean that I’m not just a developer anymore; I’m also responsible for first-line support for my own equipment. If the wifi goes down, no-one will fix it except me. If the laptop bombs out, I’ll either have to solve it myself, or find some way of setting up a temporary workspace on one of the ancient machines I have lying about until the company can send me a replacement.

Apart from that, I have no complaints about working alone. When I tell people about my situation, they usually go “Aaah, but you’ve got to have such self dicipline to be working from home.” The assumption being, that as soon as you don’t have someone looking over your shoulder, you will immediately revert to spending your working time goofing off. I don’t get that. When I’m working, I’m working. Same as if I were at the office. And there’s nothing special about me. In fact, I’m a pretty lazy guy.

I got the laptop working again, after an agonizing hour of recovery mode reboots, random fiddling with the BIOS and finally reinstalling the X server and proprietary NVIDIA drivers.

In my current project at work we have quite a few value objects with giant constructor methods; these behemoths take 20 to 30 arguments each and it’s crucial that you get all of them in the right order, which is a pain in those cases when you’re only really interested in setting one or two of them. Just as an example, let’s just say that these classes looks something like this:

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

public class ValueObj {
   private int value1;
   private int value2;
   private int value3;
   ...
   private Object obj1;
   private Object obj1;
   ...
   public ValueObj(int value1, int value2, int value2, ... Object
       obj1, Object obj2, ...) {
      this.value1 = value1;
      this.value2 = value2;
      this.value2 = value3;
      ...
      this.obj1 = obj1;
      this.obj2 = obj2;
      ...
   }

   public int getValue1() {
      return this.value1;
   }
   ... (other getter methods follow)
}

About a year ago or so we started using the Builder pattern, creating a separate Builder class for each value object class. The builder has one setter method for each parameter, and one create() method that instantiates the new object.

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

public class ValueObjBuilder {
   private int value1;
   private int value2;
   private int value3;
   ...
   private Object obj1;
   private Object obj1;
   ...

   public ValueObjBuilder value1(int value1) {
       this.value1 = value1;
       return this;
   }
   public ValueObjBuilder value2(int value2) {
       this.value2 = value2;
       return this;
   }
   ...

   public ValueObj create() {
       return new ValueObj(value1, value2, ...);
   }
}

Since the setter methods return a reference to the builder itself it is possible to chain invocations:

1

ValueObj obj = new ValueObjBuilder().value1(23).value2(47).create();

However convenient these builder classes are to use, I very quickly tired of maintaining them. Every time you add or remove a property to a value object, you also need to make the corresponding change to the builder. Keeping two classes in sync doesn’t seem like too much work, but it is unnecessary, and it occurred to me that I could probably write something to generate the builders automatically.

Writing a Maven plugin

We use Maven for our builds. Ok, ok, I know. Maven is horrible, maven downloads the whole universe, maven is braindead. Yes, I know all these things. But here’s the ting: Maven is like democracy: It’s not perfect, but it’s the best we have.

One of the nice things about maven is that it has a well-defined standard build lifecycle. The build process is divided into steps, and during one of the steps, generate-sources, a maven plugin has the opportunity to generate source that will then be compiled during the compile step.

When invoked, we’d like the plugin to:

1. Loop over our java classes, looking for constructors marked with our custom @builder javadoc comment.

2. For each matching constructor, generate a new source file under target/generated-sources/builderbuilder/ containing the Builder class.

The plugin is invoked before the compilation step, meaning that all the generated code will be included in the final output.

As an example, this code (in src/main/java/example/ValueObj.java):

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

package example;

public class Cat {
   private String name;
   private int age;

   /**
    * @builder
    */
   public Cat(String name, int age) {
      this.name = name;
      this.age = age;
   }
}

Will generate the following (in target/generated-sources/builderbuilder/example/CatBuilder.java) when run through our plugin:

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

package example;

public class CatBuilder {
   private String name;
   private int age;

   public CatBuilder name(String name) {
      this.name = name;
      return this;
   }

   public CatBuilder age(int age) {
      this.age = age;
      return this;
   }

   public Cat create() {
      return new Cat(name, age);
   }
}

For those of you who like to read along, the code for the whole plugin is on github. The finished version has some extra bells and whistles, like the ability to generate abstract builder classes and explicitly the name of the create() method.

Parsing Java code

Okay, so let’s say we want to pick apart the java class files and for each constructor found we want to generate a helper class as discussed above. Now, normally we’d use the introspection facilities already built into java, but now we have one problem: our code-generating code will run during the generate-sources step, before any compilation has actually taken places.

This is a problem. What we need is a java parser that can pull apart the relevant bits of the source files and give us enough information that so we can generate the new classes. Preferably the level of detail should be on par with with that of the java.util.reflect.* functions, and it should also be fast. I actually started writing something like that, but that’s another story. Instead, let’s check out QDox, an amazing little library used internally by maven.

Using it is pretty simple. First, create a new JavaDocBuilder object and tell it where the source code you want to parse lives:

1
2
3
4

this.docBuilder = new JavaDocBuilder();
for (String r : sources) {
    docBuilder.addSourceTree(new File(r));
}

Then loop over all known classes and generate the builder:

1
2
3

for (JavaClass jc : docBuilder.getClasses()) {
    generateBuilderFor(jc);
}

Generating the output

This is the generateBuilderFor() method:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47

public void generateBuilderFor(JavaClass jc) throws IOException {
    for(JavaMethod m: jc.getMethods()) {
        if (m.isConstructor()) {
            DocletTag dc = m.getTagByName("builder");
            if (dc != null) {
                String builderName = dc.getNamedParameter("name");
                if (builderName == null)
                    builderName = jc.getName() + "Builder";

                String packageName = dc.getNamedParameter("package");
                if (packageName == null)
                    packageName = jc.getPackageName();

                StringTemplate st = templates.getInstanceOf("builder");
                st.setAttribute("packageName", packageName);
                st.setAttribute("builderName", builderName);
                st.setAttribute("resultClass", jc.asType().toString());

                List<Param> ps = new LinkedList<Param>();
                for(JavaParameter p: m.getParameters()) {
                       ps.add(new Param(p.getType().toGenericString(), p.getName()));
                }
                st.setAttribute("parameters", ps);

                File pd = new File(outputDirectory, packageName.replaceAll("\\.", "/"));
                pd.mkdirs();

                FileWriter out = new FileWriter(new File(pd, builderName + ".java"));
                try {
                    out.append(st.toString());
                } finally {
                    out.flush();
                    out.close();
                }
            }
        }
    }
}

public static class Param {
    public final String type;
    public final String name;
        public Param(String type, String name) {
        this.type = type;
        this.name = name;
    }
}

This is all pretty straightforward; we loop through the methods for the class, looking for a constructor that has the @builder javadoc tag.

Lines 6-12 checks if the tag has any values specified for name and package, reverting to default values if not.

Lines 14-23 instantiates a new StringTemplate object and supplies it with values for the packageName, builderName and resultClass attributes (the latter being the class that we want the builder to actually build). Lines 19-23 loops through the constructor arguments and creates value object holding the name & type of each.

Finally, a new file is created (lines 25-26) and written (lines 28-34).

Templating

There are an abundance of templating frameworks out there. I choose to go with StringTemplate for this project, since it makes it easy to use subtemplates in a functional way, and generally fits my way of thinking. I could just as easily have used something like FreeMarker or Velocity, though.

The templates are not that interesting, so I won’t go into it here. You can check them out on github if you are curious.

Conclusion

Automatic code generation in java projects is not only feasible, but also quite convenient with maven. We’ve been using BuilderBuilder internally in production for a few months now, and it greatly cuts down on code maintenance.

It would be nice, though, if there was a more general approach to code generation. Just for BuilderBuilder, I had to dive into Maven internals (which are surprisingly poorly documented), learn QDox (ditto) and write all the java code that solved this particular problem. Imagine instead if there was some kind of transformation language that operated on java sources, kind of like what XSLT does for XML? Now, that would be cool.

• You don’t have to create an account to play; just sign in with you twitter or facebook account.
• Every move is represented by a card that you play. You get to keep six cards in your and you’re issued a new card randomly(?) every four minutes. This, in conjunction with that there is very little state to keep track of, means that it’s very easy to return every now and then, play a few cards and then do something else. In short, a perfect game to play while you’re code’s compiling.
• There’s a constant stream of small rewards. Almost every card played gains you a memento of some sort, and most of the mementoes can be used to unlock new paths in the game.
• Also, the setting is very athmospheric in a kind of fantasy victorian, Jonathan Strange & Mr Norrell kind of way. The writing is well done, and you get the feeling that there’s a lot to be discovered. I don’t know if there’s a conclusion or if the game ever really ‘ends’. New story segments are added weekly however, so there’s hope for some kind of coherent story.

The game builds Erin Morgenstern’s upcoming novel with the same name, and as a promotion piece it works pretty well. At the very least, it got me engaged and actually considering getting the book at some point.

Well, a couple of days ago I dusted off my Wacom Bamboo tablet, downloaded the latest version of ArtRage, and started sketching again. For some reason, everything turned out cats:

The first two were made using photo references. This is our oldest cat in various poses.

This one was actually drawn from memory. This is our smallest cat, and yes, her ears really are that large.

Soon you have collected all the expansions, and now your problem is that you’re running out of space. The base set alone contains over 700 moving parts. Each expansion adds more game boards, cards, tokens, markers and rule books. You start asking yourself exactly what ridiculous amount of game components you’ve accumulated on your quest to boardgame nirvana.

At least, that’s what I asked myself. And so I whipped together a web-based calculator using GWT and some free time. Now you too can use it to calculate the extent of your mania.

Note: The columns are sortable; try clicking on the column headings. You can filter the selection by (un)checking the boxes for different expansion sets and component types.

3222 components! Whew, that’s a lot!

So I did what any self-respecting hacker would do: I rolled my own solution using the tools I’m used to. In my case that means elisp, which is a good fit for med since Emacs is the tool I’m using to write this blog. I’ve put the code on GitHub it case it proves useful for the very small subset of Inform7 users who are also a) Emacs fanatics, and b) desperately in need of a HTML syntax highlighter.

For the past month, I have made virtually zero progress on my Interactive Fiction game. I could blame this on the stress of moving across the country while simultaneously negotiating building plans for our summer house, and then having relatives visiting the new house over easter, but I won’t. Let’s just say I need a little ignition to get going again, and I’m hoping blogging about it a bit will help.

When I first concieved the idea for the game I thought I’d be done in a day, or a weekend at most. That was back in January, and I think I might be halfway to an alpha version now. Obviously, it took a whole lot longer than I expected, mostly because I was learning Inform 7 and designing the game world at the same time as coding. One thing I did do right though, was actually writing a simple design document before I started. It had a short synopsis describing the game flow and central mechanics, and a section for each important person in the game. Nailing down names, titles, and backgrounds of the characters really helped things later on.

The games is divided into short chapters, with the viewpoint alternating between two playable characters. I want the player to feel like she’s participating in a story rather than trying to beat a game, so there are no obvious puzzles to solve. In fact, right now most of the game can be played just by moving between rooms, and waiting at the correct places. I’m considering using the subtitle A Short Story About Inevitability, but we’ll see.

Much of the plot revolves around discovering things about the player characters, either by exploring or by having conversations with NPCs. Even though the player is largely swept along for the ride, his actions do have consequences for the ending of the game. There are several different outcomes, even though they may not be obvious.

There are two things I’m doing to invite re-play of the game. First, I’m trying to pace it so that the player will never be able to get the whole picture in the first play-through. The challenge here is making the player feel intrigued rather than annoyed, and there’s a cetain risk this will backfire. Second, this will be a short game that can probably be finished within the hour.

As I mentioned earlier, I want this to feel like a proper story. This means that the player should be able to behave like she would in real life, and expect a reasonable outcome. It also means that I have to deal with certain IF staples in creative ways. For example, realism dictates that there should be certain props (like a sideboard with a tea kettle and some breakfast on a sideboard in the Dining Romm) in the game. I want the player to be able to pick up and interact with these objects, but not carry them around the house (which would spoil the overall tone of the story). Thus, I created a mechanism for handling unimportant items:

This rule ensures that an item that is declared unimportant the player will drop it before leaving the room. To make it a bit more realistic, you can name a container or supporter a resting place (for want of a better name) for each room. Unimportant objects will then be put back on the supporter or back into the container.

This is the (somewhat abridged) description of my Dining Room:

And this is how it plays:

Dining Room
Along one of the walls is a grand old sideboard crafted out of solid oak. 
Conveniently placed on it is a silver kettle, some breakfast, some china and a 
crystal decanter.

>take kettle
Taken.

>take breakfast
Taken.

>i
You are carrying:
  some breakfast
  a silver kettle
    some tea
  a candle (providing light)
  some clothes (being worn)

>w
You put the breakfast and silver kettle back on the sideboard.

[New room description snipped]

Allright, I should stop now. I just realized I spent an hour on this post instead of actually working on the darn game. See ya next time!

Naturally, this is quite a scary proposition for a city boy. I honestly don’t know if I’ll make it up there. But I was given a great opportunity, and I had to at least try. Besides, life in the city was getting a bit too convenient, if you know what I mean? It was time for a change.

Fortunately, my employer was keen to keep me on, which means that starting two weeks from now I’ll be working 100% remotely. This is a big change, and I hope it will work out for everyone involved. Our team has started using PivotalTracker and Campfire, and the overall impression is good so far. However, I will be working from my home office, and I just hope the cabin fever doesn’t get unbearable.

Another big change is that I’ll just be working 80%. Living in the northern parts of Sweden is pretty cheap, and after doing the math we decided that it wasn’t really necessary for me to work full time anymore. Instead, I’ll try to spend the extra time on fun personal projects, without having to worry about them earning me any money (although it would be nice if they did).

I’ve been longing to give game development a shot for a long time now, and this is kind of my big chance. For a guy with my background the obvious choice seems to be mobile game development with Android, and I already have some ideas to work on. I’m also really intrigued by what can be done with Common Lisp, which I believe could make for a great interactive game environment. However, my first goal is to finish my Inform 7 game, hopefully being able to enter it into IFComp 2011. Watch this space.

You know, I have a good feeling about this.