A while back I rewrote the Sparkled backend with Micronaut. The backend was a hodge-podge of libraries that worked well enough, but had some nasty glue code that I wasn't too proud of.

Micronaut is a Spring-like framework from the creators of Grails. Micronaut's raison d'être is to reduce the startup time and memory footprints of microservices by doing some heavy lifting at compile time instead of reflecting at runtime.

O [], []! Wherefore art thou []?

The Micronaut rewrite went great and everything's been running smoothly, but I came across a weird issue last night. When I hit an API endpoint that has an empty array, the array is omitted from the JSON response.

This isn't ideal. My frontend code is built on the assumption that the array will always be provided, which is reasonable since I have full control over the API.

I tried breakpointing the endpoint and serialising the object out using a plain Jackson mapper. Lo and behold, the empty array was there. Time to do some Jackson API sleuthing...

Where are the docs at?

Jackson is a great library, but its documentation really isn't great. The GitHub readme has dozens and dozens of links, with one documentation link tucked away towards the end. Hitting that link takes you to another markdown file with some third-party tutorials and a link to the jackson-docs repository.

Finally I found the Finding Javadoc page, which tells me to construct my own URL to get access to the Javadoc for a given Jackson version. That's fine, but it's quicker for me to just look at the source via IntelliJ.

The solution

After looking through the docs and going on a couple of wild goose chases, I ended up setting a breakpoint on the ObjectMapperFactory Jackson class. I hit my endpoint and then stepped through the huge objectMapper method.

I stepped through each line, and used the local mapper object to serialise an empty array at every step. This revealed the culprit pretty quickly:

objectMapper.setSerializationInclusion(include);

By default, Micronaut sets the serializationInclusion value to JsonInclude.NON_EMPTY, which omits empty objects/arrays from JSON to save space.

To remedy this, I changed the value to JsonInclude.ALWAYS in application.yml:

jackson:
  serializationInclusion: ALWAYS # Include empty arrays in JSON output

As part of a recent contract job, I was tasked with creating around 150 distinct icons to represent trains in various statuses on an interactive map. This was a task that nobody was keen to pick up, as it involved long hours in an image editor.

I volunteered for the task to free up the full-time devs who have deeper domain knowledge of the product and are therefore better suited to some of the more nitty-gritty logic problems. I quite enjoy tinkering in image editors, but I knew I'd quickly get bored of this particular task regardless.

The boring task

As I settled in and started reading the requirements, I learned that the icons are mapped to a 4 character status code, and each of the digits (sometimes a combination) dictate various features of the icon. For instance, a certain character in the code being 'E' means a train is late, and a corresponding indicator is present in the icon.

Armed with this knowledge, I realised I could turn this menial task into a fun one by generating the icons on the fly based on a provided status code. At the same time, this approach would likely be faster to implement than manually creating the icons, and make icon changes much easier in the future.

Making the task fun

It proved to be quite simple to implement the icon generation. I couldn't avoid an image editor entirely; I had to create the unique components that can make up an icon (as transparent PNGs). Fortunately, these were mostly simple shapes.

Ultimately, the icon generation code looks something like this:

/**
 * @param iconType the type of icon to generate, which includes width and height in px
 * @param trainCode a 4 character code representing a train's status
 * @return the generated icon
 */
public BufferedImage generateIcon(IconType iconType, String trainCode) {
  List<BufferedImage> iconComponents = Arrays.asList(
    getBodyBackgroundImage(iconType, trainCode),
    getBodyImage(iconType, trainCode),
    // more components...
  );

  BufferedImage result = new BufferedImage(iconType.getWidth(), iconType.getHeight(), 
      BufferedImage.TYPE_INT_ARGB);

  // Stack the components together to create the final image
  for (BufferedImage iconComponent : iconComponents) {
    result.getGraphics().drawImage(image, 0, 0, null);
  }

  return result;
}

The takeaway

There's caching and some application-specific warts to contend with, but this blog post isn't really about the implementation of this feature.

At its essence, the icon generation was quick to implement and resulted in an elegant, fun solution to a boring problem. I put this post together to remind myself (and you, if you're reading!) that the "fun-ness" of a task can have very real implications for the quality and functionality of the end result. I've found that I'm vastly more productive when working on something I enjoy, and this solution saved time and delivered a better result in the end.

By transforming a boring task into a fun one, you can improve your productivity and have a good time along the way!

My third ChrisLights project is something I've been meaning to try for quite some time: building an interactive staircase.

The main blocker I always faced was the task of accurately sensing where a person is on the staircase. I'd always imagined using an ultrasonic sensor for this, but the results were far too erratic when using them in the confined space around my staircase.

After realising that I could use an array of lasers and photoresistors instead, I ordered the components and started building.

It took a lot of work - especially on the wiring and soldering side of things - but I was really happy with the end result and the response I got from the video blew me away! I reached the #1 spot on /r/arduino with over 600 upvotes and 11K views, got over 900 upvotes on 9gag, and I was retweeted by the official Arduino twitter.

The Results

You can see the results (and more of an explanation) in the video below: