Micah Silverman

Use a Rules Engine to Write Better Code

Wed, 17 Feb 2021 13:00:00 +0000

Recently, I wrote an API that I am very proud of. It’s got 97% test coverage. It aggregates a number of other APIs to accomplish a complicated flow in just two calls. It makes use of two-factor authentication for verification purposes.

I didn’t like how long and branchy my controller code was, though. I started to search around for design patterns or approaches that would enable me to get rid of all the ifs. I found this excellent post on Baeldung that led me to the Rule Engine pattern. From the post: A RuleEngine evaluates the Rules and returns the result based on the input. In the example, each rule’s evaluate method returns true or false. Once any of the rules evaluates to true, processing in the RuleEngine stops. If none of the rules evaluates to true, then an Exception is thrown.

This was very close to what I needed. In my case, the behavior of the RuleEngine needed to be slightly different. Each API call (sometimes to different APIs) returned either a success or failure result. If any API call returns a failure, processing stops. If every API call is succesful, then an overall success result is returned. I called my implementation a StepsEngine where each of a number of Steps is evaluated.

The rest of this post reviews how the code started and where it went. I made a separate project from the production one I described above that still illustrates the approach well. You can find it here on GitHub.

Hitting Every Branch on the Way Down

I’m a huge fan of anime in general and, in particular, of all the Miyazaki films from Studio Ghibli. It turns out a kind soul has made a Studio Ghibli API! This is perfect to demonstrate the StepsEngine approach.

Before we get there, let’s take a look at where the project started. Like any good API, I want to break down my API calls into small chunks in a service. Here’s my GhibliService:

public interface GhibliService {

    String BASE_URL = "https://ghibliapi.herokuapp.com";
    String PEOPLE_ENDPOINT = BASE_URL + "/people";
    String SPECIES_ENDPOINT = BASE_URL + "/species";
    String FILMS_ENDPOINT = BASE_URL + "/films";

    PeopleResponse listPeople();
    PersonResponse findPersonByName(String name);
    FilmsResponse listMoviesByUrls(List<String> filmUrls);
    SpeciesResponse findSpeciesByUrl(String speciesUrl);
}

For the purposes of demonstration, I want to make a controller endpoint that aggregates a number of calls to the Ghibli API. When a request is made to this endpoint it will:

search the Ghibli API for a person using a name that is passed in
if the person is found, a list of the movies that person appears in is retrieved from the Ghiblie API
the species that person belongs to is then retrieved from the Ghibli API.
if all goes well, all of the previous results are returned in a single json response.

NOTE: in the Ghibli API, a Person is any character from a movie, including humans, gods, spirits and animals.

Here’s my first pass at the controller method:

@PostMapping(PERSON_ENDPOINT)
public ServiceHttpResponse findPerson(@RequestBody KeyValueFieldsRequest request, HttpServletResponse response) {
    PersonResponse personResponse = ghibliService.findPersonByName(
        request.getByName("name")
    );
    if (personResponse.getStatus() == ServiceHttpResponse.Status.FAILURE) {
        return setStatusAndReturn(personResponse, response);
    }
    Person person = personResponse.getPerson();
    FilmsResponse filmsResponse = ghibliService.listMoviesByUrls(
        person.getFilmUrls()
    );
    if (filmsResponse.getStatus() == ServiceHttpResponse.Status.FAILURE) {
        return setStatusAndReturn(filmsResponse, response);
    }
    List<Film> films = filmsResponse.getFilms();
    SpeciesResponse speciesResponse = ghibliService.findSpeciesByUrl(
        person.getSpeciesUrl()
    );
    if (speciesResponse.getStatus() == ServiceHttpResponse.Status.FAILURE) {
        return setStatusAndReturn(speciesResponse, response);
    }
    Species species = speciesResponse.getSpecies();
    return setStatusAndReturn(new CompositeResponse(
        ServiceHttpResponse.Status.SUCCESS, HttpStatus.SC_OK, 
        "success", person, films, species
    ), response);
}

It’s not too bad. But, there’s a lot of ifs. In the code I wrote for my real API, there were a lot more of them!

Notice that in between some of the if statements, the result from one service call is passed into the next service call. Also, after each service call, a status check is done. If one of the service calls fails, then the controller will respond with that failure immediately.

The uniform nature of the responses works well. There are specific response types, like PersonResponse, each of which implements the more general base ServiceHttpResponse.

We can easily test this controller for each of the failure possibilities along with the success outcome using Spring Boot’s MockMvc.

Testing the Twists and Turns

In my example code, I am still using Junit 4. While Spring Boot has moved on to Junit 5, I have not yet. Don’t Judge me! (I will get there).

In order to make Junit 4 work with the latest version of Spring Boot, you need the “vintage” engine in your project. Here’s the snippet from my pom.xml:

<dependency>
    <groupId>org.junit.vintage</groupId>
    <artifactId>junit-vintage-engine</artifactId>
    <scope>test</scope>
    <exclusions>
        <exclusion>
            <groupId>org.hamcrest</groupId>
            <artifactId>hamcrest-core</artifactId>
        </exclusion>
    </exclusions>
</dependency>

Gross, I know!

Here’s the real meat of the tests: the set up.

private void setupRequest(
    Status personResponseStatus, Status filmsResponseStatus, 
    Status speciesResponseStatus
) {
    PersonResponse personResponse = (personResponseStatus == Status.SUCCESS) ?
        new PersonResponse(
            Status.SUCCESS, HttpStatus.SC_OK, "success", person
        ) :
        new PersonResponse(Status.FAILURE, HttpStatus.SC_NOT_FOUND, "failure");
    FilmsResponse filmsResponse = (filmsResponseStatus == Status.SUCCESS) ?
        new FilmsResponse(Status.SUCCESS, HttpStatus.SC_OK, "success", films) :
        new FilmsResponse(Status.FAILURE, HttpStatus.SC_BAD_REQUEST, "failure");
    SpeciesResponse speciesResponse = 
        (speciesResponseStatus == Status.SUCCESS) ?
        new SpeciesResponse(
            Status.SUCCESS, HttpStatus.SC_OK, "success", species
        ) :
        new SpeciesResponse(
            Status.FAILURE, HttpStatus.SC_BAD_REQUEST, "failure"
        );

    when(ghibliService.findPersonByName(NAME)).thenReturn(personResponse);
    when(ghibliService.listFilmsByUrls(FILM_URLS)).thenReturn(filmsResponse);
    when(ghibliService.findSpeciesByUrl(SPECIES_URL))
        .thenReturn(speciesResponse);
}

This method takes three parameters to indicate the expected status of the service calls in the chain of calls that are made in the controller. This makes it easy to have multiple tests with different conditions for success and failure. The general rule of thumb with this setup is that if the associated service call is expected to succeed, then Status.SUCCESS is passed in. If it’s expected to fail, then Status.FAILURE is passed in. If it’s not expected that the associated service call will be reached (due to a previous failure), null is passed in.

Since all the tests against the controller will be with the same POST request, there’s another helper method to keep the tests small and focused:

private ResultActions doPerform() throws Exception {
    return mvc.perform(post(API_URI + API_VERSION_URI + PERSON_ENDPOINT)
        .contentType(MediaType.APPLICATION_JSON)
        .content(mapper.writeValueAsString(request))
    );
}

If you’re not already familiar with Spring’s MockMvc testing features, it provides a compact domain specific language (DSL) for interacting with the controller.

In the above code, I use the MockMvc object’s perform method. I pass perform a call to post with the endpoint already defined in the controller. I’ve also set up the request content as an object, which can be be easily serialized to a string using the mapper built into Spring Boot.

Here’s what one of the tests look like:

@Test
public void personEndpoint_Fail_atFindByPerson() throws Exception {
    setupRequest(Status.FAILURE, null, null);

    doPerform().andExpect(status().isNotFound());
    verify(ghibliService, times(1)).findPersonByName(NAME);
    verify(ghibliService, times(0)).listFilmsByUrls(FILM_URLS);
}

Notice that the first parameter in the setupRequest call is a FAILURE status and the other two parameters are null. This lines up with our expectation of the findPersonByName call on the GhibliService failing for this test.

Here’s a snippet from the controller method:

...
PersonResponse personResponse = ghibliService.findPersonByName(request.getByName("name"));
if (personResponse.getStatus() == ServiceHttpResponse.Status.FAILURE) {
    return setStatusAndReturn(personResponse, response);
}
...

If the findPersonByName call fails, none of the other service calls will be called as the controller returns at that point. The calls to verify at the end of the test confirm this outcome. We expect that findByPersonName has been called once and that listFilmsByUrls has not been called at all.

Each test exercises the next service call with the previous service calls succeeding. Here’s the second-to-last test:

@Test
public void personEndpoint_Fail_atFindSpecies() throws Exception {
    setupRequest(Status.SUCCESS, Status.SUCCESS, Status.FAILURE);

    doPerform().andExpect(status().isBadRequest());
    verify(ghibliService, times(1)).findPersonByName(NAME);
    verify(ghibliService, times(1)).listFilmsByUrls(FILM_URLS);
    verify(ghibliService, times(1)).findSpeciesByUrl(SPECIES_URL);
}

Here you can see that the findByPersonName and listFilmsByUrls service calls will succeed while findBySpeciesUrl service call will fail. We verify that each of the service calls have been executed at the end.

The final test is almost exactly the same as the above test with the exception of the setupRequest call:

setupRequest(Status.SUCCESS, Status.SUCCESS, Status.SUCCESS);

In the final test, the expectation is that all the service calls will succeed.

The point of all these tests is that after we refactor the controller code to take advantage of the StepsEngine, the tests should all still pass.

Step it up to the Next Level

The goal here is to get rid of all the branching in the controller, while still keeping the code readable and having all the tests pass.

Spoiler Alert! Here’s the final form of the controller method:

@PostMapping(PERSON_BY_ENGINE_ENDPOINT)
public ServiceHttpResponse findPersonEngineStyle(
    @RequestBody KeyValueFieldsRequest request, HttpServletResponse response
) {
    StepsEngine stepsEngine = setupEngine();
    ServiceHttpResponse serviceHttpResponse = stepsEngine.process(request);
    return setStatusAndReturn(serviceHttpResponse, response);
}

Three lines! Not too shabby! And, the setupEngine method is pretty lean too:

private StepsEngine setupEngine() {
    StepsEngine stepsEngine = new StepsEngine();
    stepsEngine.addStep(new PersonResponseStep(ghibliService));
    stepsEngine.addStep(new FilmsResponseStep(ghibliService));
    stepsEngine.addStep(new SpeciesResponseStep(ghibliService));
    stepsEngine.addStep(new CompositeResponseStep());
    return stepsEngine;
}

Examining the setupEngine method, you can see the order of the steps:

PersonResponseStep
FilmsResponseStep
SpeciesResponseStep
CompositeResponseStep

If any of these steps fails, we expect that our controller will return an appropriate failure response. If all the steps succeed, we expcet that our controller will return the CompositeResponse.

How is all this accomplished with our 3-line controller method? It seems like magic! It’s really a combination of the Java 8 streams api and Java generics that allows the system to work. Let’s look deeper.

At the heart of the system is the Step interface:

public interface Step {

    Status evaluate(KeyValueFieldsRequest request);
    ServiceHttpResponse getResponse();
}

Every step, when evaluated, takes a uniform request object as a parameter and returns a Status. Status is an enum with two values: SUCCESS and FAILURE.

There’s also a getResponse method that returns a ServiceHttpResponse object. There are a number of implementations of ServiceHttpResponse that we’ll review below.

Here’s the first step implementation:

public class PersonResponseStep implements Step {

    private final GhibliService ghibliService;
    private PersonResponse personResponse;

    public PersonResponseStep(GhibliService ghibliService) {
        this.ghibliService = ghibliService;
    }

    @Override
    public Status evaluate(KeyValueFieldsRequest request) {
        personResponse = ghibliService.findPersonByName(
            request.getByName("name")
        );
        return personResponse.getStatus();
    }

    @Override
    public ServiceHttpResponse getResponse() {
        return personResponse;
    }
}

The step requires the GhibliService, so it’s passed into the constructor. This pattern works well when you have a number of services that interact with different APIs.

Let’s take a look at the StepsEngine itself to see just how the engine works.

public class StepsEngine {

    private final List<Step> steps = new ArrayList<>();

    public void addStep(Step step) {
        steps.add(step);
    }

    public ServiceHttpResponse process(KeyValueFieldsRequest request) {
        Step step =  steps.stream()
            .filter(s -> s.evaluate(request) == Status.FAILURE)
            .findFirst()
            // if nothing fails, last step must be success
            .orElse(steps.get(steps.size()-1));
        return step.getResponse();
    }
}

Here’s where the magic of the streams interface (introduced in Java 8) comes into play.

There’s a List of steps that gets filled out through the addStep method.

The process method takes in the request object that all the steps must know how to handle.

The line with .filter calls the evaluate method of each of the steps and returns that step if the Status is FAILURE.

The call to findFirst() ensures that the stream is interrupted if a FAILURE occurs. The step that failed is assigned to the step variable.

Finally, the orElse is hit when all steps have run successfully. In that case, the last step is assigned to the step variable. It is therefore important that you define a step that represents your overall success state and that it be the last step in your list.

After the stream is done - whether the result is success of failure - the ServiceHttpResponse from the assigned step is returned.

This is all pretty straightforward so far, but there’s a problem that you run into almost right away. That problem is state.

Look at this snippet from the original controller method:

        PersonResponse personResponse = ghibliService.findPersonByName(
            request.getByName("name")
        );
        ...
        Person person = personResponse.getPerson();
        FilmsResponse filmsResponse = ghibliService.listFilmsByUrls(
            person.getFilmUrls()
        );

Here, we’re passing the result of one service call into the method of the next service call.

In order for our StepsEngine to function properly, we’re going to need to save state.

Here’s the updated Step interface:

public interface Step {

    @SuppressWarnings("unchecked")
    default <T> T fetchState(String key) {
        return (T) getStateContainer().get(key);
    }

    default void saveState(String key, Object value) {
        getStateContainer().put(key, value);
    }

    Map<String, Object> getStateContainer();
    void setStateContainer(Map<String, Object> stateContainer);
    Status evaluate(KeyValueFieldsRequest request);
    ServiceHttpResponse getResponse();
    ...
}

a Map<String, Object> is a handy and cheap way to save state along the way. It accomodates saving various types of objects in a flow that can have many steps.

However, casting can get annoying, so I use some generics magic to alleviate that. That’s what the fetchState method is for.

Since all the steps must now implement getStateContainer and setStateContainer, it’s useful to introduce an abstract class that implements those two methods. The various step classes can then just extend that abstract class.

public abstract class BasicStep implements Step {

    private Map<String, Object> stateContainer;

    @Override
    public void setStateContainer(Map<String, Object> stateContainer) {
        this.stateContainer = stateContainer;
    }

    @Override
    public Map<String, Object> getStateContainer() {
        return this.stateContainer;
    }
}

Now, Let’s take a look at the refactored PersonResponseStep:

public class PersonResponseStep extends BasicStep {

    public static final String PERSON_KEY = "person";

    ...
    @Override
    public Status evaluate(KeyValueFieldsRequest request) {
        personResponse = ghibliService.findPersonByName(
            request.getByName("name")
        );
        saveState(PERSON_KEY, personResponse.getPerson());
        return personResponse.getStatus();
    }
    ...
}

Each step is responsible for defining the key that will be used in the state container. In this case, the saveState method is called with the PERSON_KEY and the Person object from the PersonResponse.

Take a look at the next step in the chain, FilmsResponseStep:

public class FilmsResponseStep extends BasicStep {

    public static final String FILMS_KEY = "films";

    ...
    @Override
    public Status evaluate(KeyValueFieldsRequest request) {
        Person person = fetchState(PERSON_KEY);
        filmsResponse = ghibliService.listFilmsByUrls(person.getFilmUrls());
        saveState(FILMS_KEY, filmsResponse.getFilms());
        return filmsResponse.getStatus();
    }
    ...
}

In its evaluate method, it uses fetchState to get the Person from the state container. Because of the generics used in the definition of the method in the Step interface, a cast is not required here.

Now the service method can be called with the Person object retrieved from the state container. This step adds to the state container with its defined key FILMS_KEY after the service call.

The StepsEngine along with the generified stateContainer makes the whole system hang together.

Revisiting the Tests with the Engine

Now that we’ve refactored the pieces of the original controller method to use the StepsEngine, all our tests should still pass. As a reminder, here’s what the controller method now looks like:

@PostMapping(PERSON_BY_ENGINE_ENDPOINT)
public ServiceHttpResponse findPersonEngineStyle(
    @RequestBody KeyValueFieldsRequest request, HttpServletResponse response
) {
    StepsEngine stepsEngine = setupEngine();
    ServiceHttpResponse serviceHttpResponse = stepsEngine.process(request);
    return setStatusAndReturn(serviceHttpResponse, response);
}

If you remember from before, I showed you the doPerform method that sets up the MockMvc request to call the controller endpoint. In order to support both the steps engine and branching approaches in the controller, I have two endpoints: PERSON_ENDPOINT and PERSON_BY_ENGINE_ENDPOINT. In the controller test, I have two setup methods each of which calls a base method to get everything set up with one endpoint or the other:

private ResultActions doPerformBase(String endpoint) throws Exception {
    return mvc.perform(post(endpoint)
        .contentType(MediaType.APPLICATION_JSON)
        .content(mapper.writeValueAsString(request))
    );
}

private ResultActions doPerform() throws Exception {
    return doPerformBase(API_URI + API_VERSION_URI + PERSON_ENDPOINT);
}

private ResultActions doPerformByEngine() throws Exception {
    return doPerformBase(API_URI + API_VERSION_URI + PERSON_BY_ENGINE_ENDPOINT);
}

Now I can run tests against both endpoints and they should all pass. And, as you can see below, they all do!

Get Your Engines running

Hopefully you’ve found this post useful in how to reduce branching in your controllers. There are a number of pros and cons to the Rules Engine approach taken here:

Pros:

very compact controller code
encapsulation of steps in their own classes
easy to test
works great in situations with multiple external apis with lots of steps

Cons:

more classes (one per step)
need to maintain state
might require more hunting around for code to understand the flow

You can find my demo project here on Github.

The original post that this work is based on is on Baeldung.

You can find me on twitter: @afitnerd

Man in the Middle Yourself to See What Your IoT is Up To

Sun, 09 Aug 2020 13:00:00 +0000

Can you name all of the Internet connected devices in your house right now? You might be surprised to learn what’s connected and what’s not and maybe even what you’ve forgotten about!

Take my mom, for example. She has a MacBook, an iPad, a Galaxy S8, an Amazon FireTV Stick, an Amazon Echo Show 8. And, that’s just what I know about. Like many of us, she may also have a smart tv. She has a medic alert fob that she wears around her neck. You know, the “Help! I’ve fallen and I can’t get up!” I bet that has an IP address or, at least the base station does.

In my house, I favor devices that I can hook up to Alexa to control. Every now and then, though, I end up with something that can’t (yet) integrate with Alexa. I recently got a mini-split air conditioner installed to keep my office - which sits over a garage - cool in the summer without taxing the rest of the house. The unit I chose has an app, but it does not integrate with Alexa. I’ll save the brand-name for a follow up post, because using the tools and techniques I talk about in this post, I discovered a serious security flaw in the app!

One of my favorite posts of all time is about reverse-engineering the August Lock API. In this post, the author uses a reverse-proxy, called Charles Proxy to affect a man-in-the-middle attack on his own network to discover the calls that the August App was making to its servers.

In this post, I will cover a mobile app proxy called HttpCanary as well as Charles Proxy. HttpCanary is only available for Android, so apologies in advance if you’re on an iOS device. Charles Proxy runs on your Mac, Windows or Linux desktop.

Insomnia is a Good Time to Hack

Earlier in the week, I was struck with some bad insomnia. This happens from time to time with me. After watching 3 episodes of season 2 of Umbrella Academy, I got to thinking about how I could Alexa-ify my mini-split air conditioner. It had an app that required me to register for an account. I can use the app off my network, which means that both the app and the AC connect to some central server somewhere to communicate.

I was already familiar with Charles Proxy, but I (lazily) didn’t want to get up out of bed to get my laptop. So, I did a quick search and found HttpCanary. Most reverse proxies available for Android require you to root your device. HttpCanary, ingeniously, installed a certificate and sets up a VPN all within bounds of stock Android. Once I had it configured, I launched the AC app, logged out, logged in again, turned it on and off, and changed the temperature. Switching back to HttpCanary, I could see all this traffic.

If an app is using a service properly, it will have certificate pinning configured. This makes it harder for the reverse proxy to do its job. Ordinarily, you’d need a rooted-device with some additional software. You can do this both on Android (rooted) or iOS (Jailbreak). Fortunately, HttpCanary can install a root certificate in Firefox, so it’s easy to snoop on all of its network traffic. My AC app did not have certificate pinning properly configured, and so I was able to use HttpCanary with it without issue. More on that in the next post!

HttpCanary for Capturing in Bed

In HttpCanary, you can search for apps that you want to monitor. You then click on the paper airplane icon in the lower right to enable its vpn and start it listening. The cool thing is that on my Samsung (and maybe other Android 10 devices?), I can have canary in a floating window and see all the traffic it’s capturing.

Here’s a fullscreen view of the app:

Use Charles Proxy for the Big Guns

Charles Proxy is a paid app, but it has a free trial. If you really want to dig into what your IoT devices are doing, Charles Proxy is for you. In the screenshot below, You can see some traffic I’ve captured from afitnerd.com

I can easily configure my mobile device to use the proxy server running on my laptop. On Android, you go to Settings > Connections > Wi-Fi. Touch the gear icon next to your Wi-Fi connection and choose Advanced. Then, choose Proxy > Manual and enter in the IP address of the machine your Charles Proxy is running on.

Note: If you’re not sure of the IP Address where Charles Proxy is running, you can choose Help > Local IP Address from the menu and it will tell you. Also, Charles Proxy runs on port 8888 by default.

What’s Next in IoT Hacking

This week I will disclose my security findings to the maker of my AC unit. Hopefully they will respond and indicate that they are fixing the issue. Keep an eye out for the next post, where I’ll dig into hacking my AC unit with Charles Proxy and HttpCanary.

We're in a Golden Age of Home Automation

Sat, 01 Aug 2020 13:00:00 +0000

No More Robots

A frequent lament of my daughter is, “No more robots, Dad!” I was a very early adopter of home automation, which included things like ReplayTV and X10 in the late ’90s and early aughts.

I had the very first Roku and we cut cable and switched to Internet-only service around 2008. It was almost as expensive to have just Internet back then as it was to have Internet, TV and phone service bundled together. I’d always thought that the TV would tie into home automation and some early attempts included showing caller id on-screen via cable boxes.

Fast forward a few years and around 2014, I bought two devices: a first generation Amazon FireTV Stick and a first generation Amazon Echo Dot. I was travleing a lot and the limitations of the Roku made me want to look at a new platform. I wanted to be able to install a VPN client so that I could access my home media server when on the road. The Roku was completely closed and proprietary while the FireTV platform was a custom build of Android. This enabled me to side load the OpenVPN client. I was intrigued by the Echo platform, but I was more interested in home automation than in listening to music. So, the Echo Dot was perfect. At this time, the Philips Hue platform was already released, so I bought my first modern home automation kit: two Philips Hue dimmable bulbs and a Philips Hue bridge. Combined with the Echo Dot, I could now say: “Alexa, turn on my light 50%”. This was a revelation to me. My wife and daughter were much less impressed with this than I was.

I now have six different brands of devices all of which I can issue voice commands to from anywhere in my house. This includes everything from: “Alexa, turn on the fireplace” and “Alexa, tell Simplisafe goodnight” to “Alexa, turn on the bedroom fan 50%” and “Alexa, tell the Deebot to vacuum”.

Down with Vendor Lock-in, Long Live Vendor Lock-in!

What Amazon, Google and Apple (to a lesser degree) did with home automation is nothing short of brilliant. They made it so that you could use a variety of smart-speaker enabled plugs, switches, bulbs and other types of devices. No vendor lock-in. However, it became much more likely that you’d settle on one brand as the “nerve center” of all this automation. I ended up with Amazon. I’ve been told by friends (and have not verified for myself) that Google’s Home line of smart speakers is more sophisticated than Amazon’s Echo line. Even if that’s true, it’s unlikely that I would switch any time soon (I have an unopened Google Home mini in my storage closet. I’ll send it to the first person to @afitnerd me on Twitter and venmo me the cost of shipping).

So, I am pretty locked in to Amazon. But, I am free to range around all the devices that support the Amazon platform. And, most of the devices I buy these days support Amazon and Google, at least.

The Philips Hue Case Study

I got my first Philips Hue kit nearly at the time it dropped. We used those bulbs for years. Every now and then I’d have to reset the hub, but it was infrequent enough that it didn’t bother me. I never bought additional Hue bulbs because they were expensive compared to other other brands coming onto the smart bulb scene. That didn’t matter since the GE bulbs I got later on integrated with Amazon Alexa just as easily as the Philips Hue bulbs had.

On April 30th, 2020, Philips not only discontinued support for the v1 hub, they made it lose all Internet connectivity, making it inoperable with any smart devices. You could still control the bulbs with the mobile app, as long as the hub and the app were on the same network. The v1 hub was introduced in 2012 and eight years is a long time in Internet years. There were a number of security concerns with the v1 hub, which is why Philips said they were dropping ongoing support for it. The v2 hub was released in 2015, had a faster processor and would have continued support from Philips (or, so they said).

But, fool me once… - I didn’t like that Philips might brick future devices I would buy from them. True to their promise, on May 1st, I could no longer control my bulbs from my Amazon devices. I reached out to Philips, hoping to get a discount on a v2 bridge. It’s currently priced at $58 on Amazon. To their credit, the Philips Twitter account was very responsive:

The bottom line, though, was that there were no promos I could use to offset the cost of the v2 bridge in order to keep using my Hue bulbs. Well, I couldn’t fault them too much. In 6 years, I’d only ever bought the hub and the two bulbs. I might have been more upset or might have bitten-the-bullet and bought the v2 hub, but for the fact that there were so many other options!

I hunted around and bought a C by GE starter kit. It was on sale at the time for $36. I was impressed that GE built their hub into the smart plug that could connect to my network wirelessly and could control up to 50 bulbs. So, for 28% less than the cost of a Hue v2 bridge, I got four dimmable bulbs and a smartplug. I’ve since bought another 4 bulbs and easily connected it to my existing smart-plug-bridge.

This is a perfect example of avoiding vendor lock-in thanks to the architecture that Amazon and Google provided for their smart devices.

Upward and Onward with Home Automation

Currently, I have a boat load of switches, plugs and devices in my house that I control via the 6 various Amazon devices I have as well. Here’s a list (note: these are affiliate links and I get some cents if you follow them and make a purchase):

I hope you dug my little tour of home automation. I’d love to hear your experiences. At me at @afitnerd on twitter or comment on this post.

Travel Necessities of the Modern Road Warrior

Fri, 12 Jul 2019 13:00:00 +0000

I’ve now been a full time Developer Evangelist for 4 years (at two different companies). Over this period of time, my travel requirements have steadily increased. At this point I am averaging travel two out of four weeks every month and over the next two months, I will be in ten different locations, including international travel to Australia.

Like most people in Developer Evangelism (or Developer Relations or Developer Advocacy), my travel expenses are covered by the company I work for. So, clean, decent hotels are the baseline. I am very particular about my “creature comforts” when I travel, and most hotels - even great ones - tend to fall short.

In this post, I share with you my essentials for travel along with links. What follows is 100% opinion. YMMV!

What you Need to Get There

At $85 for five years, TSA Precheck is well worth the cost. If you’re not familiar with the service, you make an appointment at a local office or at an airport. You get a background check and you get finger-printed. Once approved, you get to go on a faster line at the airport. And, more importantly, you don’t have to remove your belt or lightweight jacket. Nor do you have to take your laptop out of its case. Recently, I’ve also purchased Clear. This gets you through security even faster. When you register for Clear, your retina and finger prints are scanned. At the airport, you go to the Clear kiosks and scan your retina or fingerprints. Once verified, you’re escorted to the front of the pre-check line and you need only show your boarding pass to the TSA Agent. You don’t even have to show your id! Clear is more expensive at $179 / year and it’s not available at all airports.

As often as possible, I try not to check luggage. I use carry-on luggage. I like to get on and off the plane and out of the airport as quickly as possible.

I’ve gone through a number of iterations with carry-on luggage. In the past, I’ve been super cheap - and paid the (actual) price. That is, luggage that falls apart, or has wheels that lock up or wear out, or is not designed well for efficient packing. I recently purchased the Bigger Carry-On by Away and it’s superb. The wheels are smoothy-smooth. The zippers are tough, but easy to open and close. Inside, the right section has a metal-framed mat that sits over your clothes and has straps across it that when tightened, compress everything down. The left section is a spacious open compartment for loose items, like shoes. I chose the battery, which has a 10,000mAh ejectable battery pack. It’s perfect for quick charging while waiting to board at the airport. It comes in at $245 and (most importantly) has a lifetime warranty. I’ve spent way more than this on a bunch of cheapo luggage with basically no warranty.

What you Need when You’re There

When I arrive at a hotel, I like to make it my own. It usually takes me 5 - 10 minutes to “customize” the room. But once I’m done, everything is just the way I like it.

Hotels have Shitty Internet

Hotel WiFi tends to be slow at best, and insecure at worst. Using a VPN on hotel WiFi can make it even slower. Fortunately, most hotels have a wired connection. That’s why I travel with a TP-Link compact wireless router. This serves two purposes. The first is that I get better speed. The second is that all my devices are all ready to connect to the WPA2 protected network. This alleviates the need to navigate the usually terrible captive portal flow on devices like my Amazon FireTV Stick.

This brings me to the next point.

Hotels have Shitty TV

There. I said it! As much as I love Mario Lopez, I’m tired of him being the first thing I see when I turn on a hotel tv. I cut cable a long time ago. I’m a creature of habit and I don’t like to have to endure commercials and E! entertainment just because I am at a hotel. One of the first things I do is pop my Amazon FireTV Stick into an available port on the TV.

My favorite hotels have a module - often embedded in furniture - that allows you to plug an HDMI device right in. Often times, I have to go hunting around the back of the TV for an available port.

Occasionally, a hotel will have any access to ports on the TV blocked off. That’s why I bought this cheap HDMI coupler. In these cases, I can just hijack the HDMI cable coming out of the cable box and connect it to my FireTV without needing access to the back of the TV.

Hotels are Mad Dry

I rarely get sick. But, I’ve been getting sicker more often as I amp up my travel schedule. Being trapped in a metal test tube with everyone else’s germs and then going to a dusty, dry hotel - well, it’s enough to turn anyone into a germophobe.

I found this great little travel humidifier that Feng Shui’s up the hotel room a bit. It may be psychosomatic, but I don’t get dry throat or cough when I use it on the road.

As an aside, I use the Quip toothbrush (full disclosure - that is an affiliate link). It turns out that the plastic tube the Quip comes in is perfect for keeping long body of the humidifier in. You just have to be careful to let it dry out from time to time so you don’t end up with a science experiment.

Hotel Power Outlets are Infuriating

It seems that most of the hotels I stay at - even really nice ones fall into two camps with regard to power outlets. Either there aren’t enough or there’s a bunch located across the room in some inconvenient spot.

This is something that’s improving as a number of hotels I’ve stayed at recently have clocks or lamps with power outlets and USB ports.

I travel with this 5 outlet wonder. In addition to the 5 3-prong power outlets, it has a retractable cord, 2 USB-A ports and even a USB-C port. I will sacrifice a lamp on the night table to have this plugged in.

Honorable Mentions

There’s a whole bunch of other kit I have with me to make traveling easy and functional.

I use the eBags Professional Slim Laptop Backpack. It’s got a ton of storage while still being reasonably slim. It always fits under the seat on the airplane.

I love the Omnicharge product line and I’ve backed their products on Kickstarter. The one I use now is the Omni 20+. It’s beefy 20,000mAh battery is in a lean enclosure with an unholy number of ports, including USB-C, USB-A and a standard 3-prong 120V outlet. You can plug nearly anything into it and charge it via nearly any of its ports. I can run my 15” MacBook Pro off it for nearly 2 hours. It even has 10W wireless charging. I can just place my phone on top of it and bam - it’s charging.

I always have a couple of retractable ethernet cables on me to use when I’m onsite with a customer or in the hotel room using my WiFi router.

Getting the right size travel containers for shampoo, body wash, etc. can be a pain. It needs to be 3oz or less to be in my carry-on. It needs to be totally leak proof. These silicon travel tubes do the trick nicely.

The Full Travel Kit

I hope this post helps you if you travel a lot as I do.

Here’s the full list of my travel gear:

I’ve also organized this on kit where you can see all the items in one place.

Feel free to shoot me any questions at: micah@afitnerd.com or tweet at me: @afitnerd

Omni Charge Delivers Power

Sat, 03 Feb 2018 13:00:00 +0000

As a Samsung Galaxy S8 owner and software developer with a 2016 MacBook Pro, Apple has done me a huge favor in moving over to USB-C for all its ports.

Of course, they completely screwed over their loyal iPhone customers in doing so. But, that’s a post for another time.

USB-C is the perfect standard for modern devices as the same port can be used both to charge the pack itself and to charge the external device.

This post is all about my quest for the perfect battery backup.

Let’s start with the punchline: The omni 20 usb-c is it.

Over the years, I’ve gone through a lot of battery backups. I quickly discarded the type that you get from conferences as not viable for my needs. Those are usually around 2500mAh and, aside from being barely able to fully charge a modern mobile device even once, they don’t hold their own charge, so you end up with a dead battery backup when you need it most.

For quite a while I was very happy with my iMuto 16.750mAh backup. They’re now pitching it as a “portable chargeer for Nintendo Switch”. Can’t say I blame them. That Nintendo Switch is so hot right now…

This battery backup was the first I’d found with a native USB-C port. It charged up super quick using a USB-C wall charger and fast-charged my Nexus 6P and later, my Samsung S8. It holds its charge for a very long time. It’s rugged and the simple LED display lets you know how much juice you have left.

Then, I got the new MacBook Pro with 4 USB-C ports. I was excited to see what the iMuto could do, if anything. The MBP has pretty heavy duty power requirements and at a max output of 15 Watts, the iMuto just wasn’t up to the task.

Then, the Internet spoke. I became interested in the omnicharge when they announced their 120V inverter battery backup. It was originally on Indiegogo and, at the time, I decided not to buy it. While it’s more general purpose, I heard that they were coming out with a USB-C model. That would fit better with the amount of travel that I do. For any of my non-USB-C devices, like my iPad mini, I bought USB-C cables. No dongles for me. I’m all in on USB-C.

The Unboxening

The omni 20 usb-c comes in a minimalist box. Inside, it has a small set of stickers, a square card with a url for the user manual and the battery backup itself nestled in squishy foam.

Setup and Testing

The manual recommends that you perform an initial “calibration” by draining the battery to 0% and then charging it to 100%. Out of the box, it showed 18%. I connected my Samsung S8, iPad mini and, the iMuto 16,750mAh battery pack to it and waited until it was dead.

I then connected it to my USB-C native 29W Apple power supply and a little over 2.5 hours later, it was back to 100%. The manual says it will take 3 hours to charge, so - right on track there.

Next, I wanted to see how long it would power my 15” MacBook Pro under load. This is a more “real world” test than the usual “ideal conditions” type of test.

The test was simple - How long would it keep my MBP at 100% with the charging indicator showing.

When I say, “under load”, I mean it! I started the test at the beginning of a 7-hour screenshare, during which time I was teaching a course. In addition to screen sharing, I was running Powerpoint and I was connected to a virtual machine environment - effectively screesharing a remote screen! And, I was driving two external 27” displays in addition to the built-in display.

The omni 20 usb-c lasted for 1 hour, 45 minutes. I’m quite pleased with that result as the conditions that I would normally be using the battery backup under would be much less severe. My most common use for this will be on a long flight, where I’d have the screen brightness lower than normal and I would not be sharing my screen or driving external displays.

Some Stats

For comparison, my old iMuto weights 10.5 ounces. The omni 20 usb-c weighs 17.6 ounces. The omni is just about the same thickness as the iMuto, although it’s considerably wider. It fits in my backpack well and the extra 7 ounces is worth it.

The omni 20 usb-c can produce 45W, which is plenty to charge the MBP.

Its tiny OLED display is packed with great information including available watt-hours, battery temperature, activated ports and expected time remaining or charge time.

It has two USB-C ports and two USB-A ports.

Full stats on the omni 20 usb-c can be found here.

Full stats on the iMuto 16,750 can be found here.

Power Nerds, Unite!

I am accumulating quite a bit of USB-C powered devices. The most recent is a Nintendo Switch. While I have not yet tried to use the omni 20 with it, I am sure it will work like a champ when I want it to.

Do you nerd out over power backup solutions too? I’d love to hear your experiences in the comments section below.

What if Spring Boot Handled Forms Like JSON?

Wed, 24 May 2017 13:52:41 +0000

What follows is an unexpected journey to some of the inner workings of Spring Boot. In particular, how it handles materializing POJOs from an incoming HTTP request. It all started with an innocent look at the Slack API…

All of the code mentioned in this post can be found in the slack-slash-command-example github repo.

I use Slack. A lot. I’m currently in 12 slack orgs. One of them is even a paid org! I thought I’d play around with the Slack API and I started with Slack Slash commands, as it seemed like the easiest point of entry.

I also live and breathe Spring Boot. It’s so easy to write APIs with Spring Boot, that this seemed like the most natural place to start. Here’s the simplest one-file Spring Boot API app:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
@SpringBootApplication
@RestController
@RequestMapping("/api/v1")
public class SlackApplication {

    public static void main(String[] args) {
        SpringApplication.run(SlackApplication.class, args);
    }

    @RequestMapping("/slack")
    public @ResponseBody Map<String, Object> slack(@RequestBody Map<String, Object> slackSlashCommand) {

        return slackSlashCommand;
    }
}

Thanks to the magic of Spring Boot and its creation of a fully executable jar, I can easily fire up this example:

target/slack-slash-command-example-0.0.1-SNAPSHOT.jar

On Windows, you may have to run:

java -jar target/slack-slash-command-example-0.0.1-SNAPSHOT.jar

I can hit my API like so (I am using HTTPie, a modern curl replacement):

http POST localhost:8080/api/v1/slack \
  token=token team_id=team_id team_domain=team_domain channel_id=channel_id \
  channel_name=channel_name user_id=user_id user_name=user_name \
  command=command text=text response_url=response_url

HTTP/1.1 200
Content-Type: application/json;charset=UTF-8
Date: Wed, 24 May 2017 14:39:48 GMT
Transfer-Encoding: chunked

{
    "channel_id": "channel_id",
    "channel_name": "channel_name",
    "command": "command",
    "response_url": "response_url",
    "team_domain": "team_domain",
    "team_id": "team_id",
    "text": "text",
    "token": "token",
    "user_id": "user_id",
    "user_name": "user_name"
}

NOTE: Contrary to the way the above command looks, the data is sent over as JSON with a Content-Type header of application/json. Thank you, HTTPie.

Well, that was easy!

EXCEPT, this doesn’t work with the Slack Slash Command API at all.

Looking more closely at the API, I see that Slack does the POST with an old-school application/x-www-form-urlencoded content type.

“OK”, I thought, “Spring Boot is pretty smart, let me try sending over the params as form input rather than JSON.”

I can hit my API again, with application/x-www-form-urlencoded by simply adding --form to the command line:

http --form POST localhost:8080/api/v1/slack \
  token=token team_id=team_id team_domain=team_domain channel_id=channel_id \
  channel_name=channel_name user_id=user_id user_name=user_name \
  command=command text=text response_url=response_url

HTTP/1.1 415
Content-Type: application/json;charset=UTF-8
Date: Wed, 24 May 2017 14:55:34 GMT
Transfer-Encoding: chunked

{
  "error": "Unsupported Media Type",
  "exception": "org.springframework.web.HttpMediaTypeNotSupportedException",
  "message": "Content type 'application/x-www-form-urlencoded;charset=utf-8' not supported",
  "path": "/api/v1/slack",
  "status": 415,
  "timestamp": 1495637734535
}

Hrmph. I’ve gotten so used to modern APIs using JSON (ahem, Slack - what gives?) that I wasn’t sure how to handle regular old form input in an API. To the Google!

ModelAttributes, WebDataBinders and HttpMessageConverters - Oh My!

Turns out, Spring Boot creates Form beans with the WebDataBinder. Non-Form beans are created using an HttpMessageConverter. Spring Boot exposes the MappingJackson2HttpMessageConverter which handles the JSON mapping magic.

First thing I wanted to do was to stop using Map<String, Object> datatypes and to make a proper model object. Using Map<String, Object> is a handy trick when you’re interacting with an external API and you’re not sure exactly what you are going to get from it. So, I created the FormSlackSlashCommand model:

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
public class FormSlackSlashCommand {

    private String token;
    private String command;
    private String text;

    @JsonProperty("team_id")
    private String teamId;

    @JsonProperty("team_domain")
    private String teamDomain;

    @JsonProperty("channel_id")
    private String channelId;

    @JsonProperty("channel_name")
    private String channelName;

    @JsonProperty("user_id")
    private String userId;

    @JsonProperty("user_name")
    private String userName;

    @JsonProperty("response_url")
    private String responseUrl;

    ...
    // setters and getters
}

Hold on, there! If this POJO is used for Form handling, why all the @JsonProperty annotations? Well, I want to be able to return this POJO as JSON, with properties that conform to the Slack API. These annotations don’t get in the way of our Form processing in any way. We’ll see how they come into play shortly.

Here’s an updated Controller:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
@RestController
@RequestMapping("/api/v1")
public class SlackController {

    private static final Logger log = LoggerFactory.getLogger(SlackController.class);

    @RequestMapping(
        value = "/slack", method = RequestMethod.POST,
        consumes = MediaType.APPLICATION_FORM_URLENCODED_VALUE, produces = MediaType.APPLICATION_JSON_VALUE
    )
    public @ResponseBody FormSlackSlashCommand slack(@ModelAttribute FormSlackSlashCommand slackSlashCommand) {
        log.info("slackSlashCommand: {}", slackSlashCommand);

        return slackSlashCommand;
    }
}

Notice the consumes and produces attributes of the @RequestMapping annotation. This controller method will take HTTP Form input and respond with JSON.

The @ModelAttribute annotation ensures that the WebDataBinder is engaged to materialize the FormSlackSlashCommand object. Looks like we’re done! I’ll just hit the endpoint again to make sure:

http -f POST localhost:8080/api/v1/slack \
  token=token team_id=team_id team_domain=team_domain channel_id=channel_id \
  channel_name=channel_name user_id=user_id user_name=user_name \
  command=command text=text response_url=response_url

HTTP/1.1 200
Content-Type: application/json;charset=UTF-8
Date: Thu, 25 May 2017 03:55:49 GMT
Transfer-Encoding: chunked

{
    "channel_id": null,
    "channel_name": null,
    "command": "command",
    "response_url": null,
    "team_domain": null,
    "team_id": null,
    "text": "text",
    "token": "token",
    "user_id": null,
    "user_name": null
}

What the what?!? Well, Spring Boot currently just doesn’t handle Form submissions as flexibly as it does JSON. It automatically handles the “simple” attributes, like command, text, and token using the corresponding setters in the FormSlackSlashCommand. But, there is no corresponding setter to deal with attributes like: channel_id.

Here’s a two-year-old Jira issue that proposes adding an annotation for handling Form input in a similar way that the Jackson mapper handles JSON input: https://jira.spring.io/browse/SPR-13433 (I humbly request your votes on this issue!)

Following this discovery, I came up with three approaches to address handling Form input more flexibly with what’s currently on the truck for Spring Boot. Many thanks to the r/java community for the feedback in the comments of my post there.

Below follows an explanation of these approaches, from my least favorite to most favorite (and, more importantly, from worst to best approach).

First Approach: Nasty Java, Automatic Marshaling

For, my first swipe at a solution, I wanted to have the least amount of additional configuration code. Rather than deal with custom converters, I wanted to hook into the existing WebDataBinder. To do this, I needed to break some Java syntax conventions. In order to keep the primary code “clean”, I created a superclass for the sole purpose of properly materializing our Object in the controller.

I give you AbstractFormSlackSlashCommand:

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
// workaround for customize x-www-form-urlencoded
public abstract class AbstractFormSlackSlashCommand {

    public void setTeam_id(String teamId) {
        setTeamId(teamId);
    }

    public void setTeam_domain(String teamDomain) {
        setTeamDomain(teamDomain);
    }

    public void setChannel_id(String channelId) {
        setChannelId(channelId);
    }

    public void setChannel_name(String channelName) {
        setChannelName(channelName);
    }

    public void setUser_id(String userId) {
        setUserId(userId);
    }

    public void setUser_name(String userName) {
        setUserName(userName);
    }

    public void setResponse_url(String responseUrl) {
        setResponseUrl(responseUrl);
    }

    abstract void setTeamId(String teamId);
    abstract void setTeamDomain(String teamDomain);
    abstract void setChannelId(String channelId);
    abstract void setChannelName(String channelName);
    abstract void setUserId(String userId);
    abstract void setUserName(String userName);
    abstract void setResponseUrl(String responseUrl);
}

The FormSlackSlashCommand class is the same as it was, except that now it extends AbstractFormSlackSlashCommand:

1
2
3
public class FormSlackSlashCommand extends AbstractFormSlackSlashCommand {
  ...
}

Now, the WebDataBinder can handle incoming form parameters such as team_id thanks to the setTeam_id method.

Aside from a lot of boilerplate code, AbstractFormSlackSlashCommand has the drawback of violating Java method naming conventions.

On to the next approach!

Second Approach: Custom HandlerMethodArgumentResolver

u/sazzer posted the excellent suggestion of creating an HandleMethodArgumentResolver to materialize the Object in the controller. I hadn’t heard or read about a HandleMethodArgumentResolver prior to this and it turned out to be a solid approach.

Here’s the updated controller:

1
2
3
4
5
public @ResponseBody SlackSlashCommand slack(SlackSlashCommand slackSlashCommand) {
    log.info("slackSlashCommand: {}", slackSlashCommand);

    return slackSlashCommand;
}

Notice that there’s no @ModelAttribute annotation. That’s because we don’t want the WebDataBinder to materialize the SlackSlashCommand. We’ll have a custom HandlerMethodArgumentResolver do that for us.

Note: In order to exercise all of the approaches in the slack-slash-command-example, the SlackSlashCommand class is basically the same as the FormSlackSlashCommand class, except that it does not extend AbstractFormSlackSlashCommand.

Here’s the HandleMethodArgumentResolver:

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
public class SlackSlashCommandMethodArgumentResolver implements HandlerMethodArgumentResolver {

    @Override
    public boolean supportsParameter(MethodParameter methodParameter) {
        return methodParameter.getParameterType().equals(SlackSlashCommand.class);
    }

    @Override
    public Object resolveArgument(
        MethodParameter methodParameter, ModelAndViewContainer modelAndViewContainer,
        NativeWebRequest nativeWebRequest, WebDataBinderFactory webDataBinderFactory
    ) throws Exception {

        SlackSlashCommand ret = new SlackSlashCommand();

        ret.setChannelId(nativeWebRequest.getParameter("channel_id"));
        ret.setChannelName(nativeWebRequest.getParameter("channel_name"));
        ret.setCommand(nativeWebRequest.getParameter("command"));
        ret.setResponseUrl(nativeWebRequest.getParameter("response_url"));
        ret.setTeamDomain(nativeWebRequest.getParameter("team_domain"));
        ret.setTeamId(nativeWebRequest.getParameter("team_id"));
        ret.setText(nativeWebRequest.getParameter("text"));
        ret.setToken(nativeWebRequest.getParameter("token"));
        ret.setUserId(nativeWebRequest.getParameter("user_id"));
        ret.setUserName(nativeWebRequest.getParameter("user_name"));

        return ret;
    }

    private boolean isNotSet(String value) {
        return value == null;
    }
}

The supportsParameter method determines whether or not the resolver will be used to return a particular Object, in this case, a SlackSlashCommand.

The resolveArgument method uses the NativeWebRequest to obtain all of the form parameters and create a SlackSlashCommand object.

The last piece of the puzzle is to ensure that Spring Boot uses this resolver. That’s handled in a configuration:

1
2
3
4
5
6
7
8
@Configuration
public class SlackSlashCommandMethodArgumentResolverConfig extends WebMvcConfigurerAdapter {

    @Override
    public void addArgumentResolvers(List<HandlerMethodArgumentResolver> argumentResolvers) {
        argumentResolvers.add(new SlackSlashCommandMethodArgumentResolver());
    }
}

This is a solid approach. However, there’s a lot of manual labor involved in materializing the SlackSlashCommand Object. Also, it’s a little more idiomatic for a Spring Boot controller to have the @ModelAttribute or @RequestBody annotation on an Object that’s part of the request.

u/sazzer also suggested using reflection to easily convert the form parameters into setter methods on the object.

That led to my last and favorite approach.

Third Approach: Custom HttpMessageConverter

This approach has the least amount of boilerplate code and reuses existing components available to Spring Boot.

As I said toward the beginning of the post, there are a bunch of built in HttpMessageConverter classes. The most common one is the MappingJackson2HttpMessageConverter, which handles JSON.

As you would expect of Spring Boot, it’s easy to create a custom HttpMessageConverter.

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 SlackSlashCommandConverter extends AbstractHttpMessageConverter<SlackSlashCommand> {

    // no need to reinvent the wheel for parsing the query string
    private static final FormHttpMessageConverter formHttpMessageConverter = new FormHttpMessageConverter();
    private static final ObjectMapper mapper = new ObjectMapper();

    @Override
    protected boolean supports(Class<?> clazz) {
        return (SlackSlashCommand.class == clazz);
    }

    @Override
    protected SlackSlashCommand readInternal(Class<? extends SlackSlashCommand> clazz, HttpInputMessage inputMessage) throws IOException, HttpMessageNotReadableException {
        Map<String, String> vals = formHttpMessageConverter.read(null, inputMessage).toSingleValueMap();

        return mapper.convertValue(vals, SlackSlashCommand.class);
    }

    @Override
    protected void writeInternal(SlackSlashCommand slackSlashCommand, HttpOutputMessage outputMessage) throws IOException, HttpMessageNotWritableException {

    }
}

The readInternal method takes an HttpInputMessage as one if its parameters. This is essentially a raw InputStream of the incoming form parameters.

At first, I thought I would have to manually read the stream and parse the query string. Gross! Then, I remembered that the existing FormHttpMessageConverter takes an incoming form and resolves it to a MultiValueMap.

Based on the Slack Slash Command API, I also knew that all I needed was a single value map. Line 14 of the above code takes care of that.

At this point, I could manually create the SlackSlashCommand object, like I did in the SlackSlashCommandMethodArgumentResolver. However, the available Jackson ObjectMapper is all ready to take a Map and materialize it to an Object for us. As a bonus, it will make use of the @JsonProperty annotations found in the SlackSlashCommand class. Whoa - that’s a lot of power in that one line on line 16!

Just two more bits tie this approach into a neat bow.

First, the controller method now needs to use the @RequestBody annotation so that the collection of HttpMessageConverters can be inspected and used.

1
2
3
4
5
public @ResponseBody SlackSlashCommand slack(@RequestBody SlackSlashCommand slackSlashCommand) {
    log.info("slackSlashCommand: {}", slackSlashCommand);

    return slackSlashCommand;
}

Now, that looks like a proper Spring boot controller method!

We do need to register the custom HttpMessageConverter with Spring Boot. This is accomplished with a configuration as before:

1
2
3
4
5
6
7
8
9
10
11
12
@Configuration
public class SlackSlashCommandConverterConfig extends WebMvcConfigurerAdapter {

    @Override
    public void configureMessageConverters(List<HttpMessageConverter<?>> converters) {
        SlackSlashCommandConverter slackSlashCommandConverter = new SlackSlashCommandConverter();
        MediaType mediaType = new MediaType("application","x-www-form-urlencoded", Charset.forName("UTF-8"));
        slackSlashCommandConverter.setSupportedMediaTypes(Arrays.asList(mediaType));
        converters.add(slackSlashCommandConverter);
        super.configureMessageConverters(converters);
    }
}

This instantiates our SlackSlashCommandConverter, ensures that it supports x-www-form-urlencoded requests and adds it to the list of HttpMessageConverters.

The only drawback of this approach is that the @RequestBody annotation is typically used for non-form based requests. However, I think that the consumes = MediaType.APPLICATION_FORM_URLENCODED_VALUE attribute makes it clear what’s going on.

The Best Approach of All

I hope you’ve enjoyed our trek down workaround lane.

If https://jira.spring.io/browse/SPR-13433 is implemented (Did I mention about voting on it?), then none of the above approaches would be necessary. You’d simply annotate your POJO in a similar way to @JsonProperty to indicate how to map incoming form params to its fields.

In your controller, you would simply use the @ModelAttribute annotation and you’d be done.

That would truly make Form handling as civilized as JSON handling already is in Spring Boot.

All of the code mentioned in this post can be found in the slack-slash-command-example github repo.

A Fit Nerd's new home

Sun, 30 Apr 2017 20:52:41 +0000

A few days away from 6 years ago I started this blog and hosted it on wordpress. Wordpress has an awesome community, so many plugins and is (relatively) easy to setup. But, I’ve always found it a bit heavyweight for a blog.

As a developer and contributor to many open source projects, I live and breath markdown. So, it seems like a more natural fit to use Jekyll for the blog tech and to just host it on Github pages. It’s free and thanks to the Jekyll-uno plugin, looks great on desktop and mobile.

I am going to port over my posts from over the years, but it will take a little while. Since I’ve been a fair weather blogger (at best), it won’t take too long.

You can see the old posts here.

In the meantime, I ported over one of my personal favs from back in the day: my weekend project of restoring a Dark Tower game to its original glory.

Killing Distractions, Mac Automator Style

Mon, 10 Aug 2015 20:52:41 +0000

It has been a long long while since I’ve posted anything here. Life just kind of got in the way. Lame. Frankly, I’ve gotten a bit away from the “fit” part of afitnerd.com. Here’s what I am excited about: I recently took a position as the Java Developer Evangelist for Stormpath. This is such a wonderful mix of two of my favorite things - programming and writing - I sometimes can’t believe my good fortune! Shameless plug alert: I really love Stormpath and what we are up to. Check us out. And, I’ve begun putting the “fit” back in. I’m beginning to run again, starting with 3 to 5 sessions per week on the elliptical.

I am very easily distracted. I wanted to set myself up for success in my new position. When I use the pomodoro technique, I’m in a much better place.

Recently, I started using a combination of Google Chrome “people” (personas) and killing apps to try to keep distractions away while working in a pomodoro. I created a persona called “Distractions”. Here’s what the process of getting rid of distractions looks like for me:

Close the "Distractions" Google Chrome window
Quit a number of apps that are distracting when I am trying to work

YNAB - awesome budgeting software.
Sunrise Calendar - awesome calendar app.
Omnifocus - essential project and task management.
Telegram - great individual and group messaging app.
Messages - Apple messaging app that allows me to send SMS messages from the desktop.
Hipchat - awesome messaging app for work. Annoyingly, disregards "Do Not Disturb" setting on Mac.

Turn on Do Not Disturb mode

During the pomodoro break, I reverse the process.

On top of that, I like to have certain apps on certain spaces on my two-display setup. This meant CMD+Tab to the app or jump to the space, and then start it up (or kill it, depending on where I am at). With only 5 minutes in a pomodoro break, all this switching around and launching can add up.

This post is all about how I automated this process using an application that’s been in OS X for a very long time: Automator. Atomator’s been built-in since the Tiger release in 2005! And, I’ve completely neglected it even though I’ve been a full-time OS X user since 2008. Full disclosure here: I am an Automator and Applescript n00b. The Applescript examples that I am going to share with you work on my setup running Yosemite. YMMV!

There were a couple of challenges to get this working the way I wanted. First, I had to be able to launch certain apps on certain spaces. I also needed a way to open and close certain Google Chrome personas without exiting Chrome altogether.

Let’s take a look at the close distractions script first:

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
on run {input, parameters}

    tell application "Messages"
    	quit
    end tell

    tell application "HipChat"
    	quit
    end tell

    tell application "Telegram"
    	quit
    end

    tell application "YNAB"
    	quit
    end

    tell application "Sunrise"
    	quit
    end

    tell application "Omnifocus"
    	quit
    end

    tell application "Google Chrome"
    	activate
    	tell application "System Events"
    		tell process "Google Chrome"
    			click menu item "Distractions" of menu 1 of menu bar item "People" of menu bar 1
    			click menu item "Close Window" of menu 1 of menu bar item "File" of menu bar 1
    		end tell
    	end tell
    end tell

	return input
end run

Lines 3 - 25 are pretty self explanatory. For each named application, tell that application to quit. There were a couple of applications that Automator didn’t know about even though they were running. I probably just didn’t have the name exactly right. Automator gave me a picker to select the app and once I did that, the proper app would quit when I ran the script. Some secret sauce going on behind the scenes there.

Lines 27 - 35 are where things get interesting. In this case, I am activating the Google Chrome application and then interacting with the menu to accomplish the goal of closing the “Distractions” persona.

After testing this script in the Applescript editor, I was ready to create an Automator script and bind a key sequence to it. In the Automator app, I chose to create a new workflow of the “Service” type. I then dragged over the “Run Applescript” item from the library on the left. In addition to pasting in the above script, I selected some key settings that make the keyboard shortcut work the way I want it to.

Toward the top of the pane, there are two dropdowns. This service automation does not receive any input AND I want it to be available in “any application”.

I always wondered what the universal menu item “Services” that I see on all mac apps was for. Now I know - a little at least. Once I saved the automation, the workflow I had created showed up in the services menu of (nearly) any app I run.

Having these workflows available in any application is critical to being able to being able to trigger them by a key sequence. In the Keyboard System Preference pane, there’s a Shortcuts tab. On that tab, you can bind key sequences to variety of types, including Services.

I bound the “close_distractions” workflow to the key sequence:

CTRL+ALT+CMD+,

I bound the “open_distractions” workflow to the key sequence:

CTRL+ALT+CMD+.

Let’s take a look at the “open distractions” workflow code. Again, some of this is very specific to my setup. YMMV.

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
48
49
50
51
52
53
on run {input, parameters}

    do shell script "/Applications/Mission\\ Control.app/Contents/MacOS/Mission\\ Control"
    delay 0.5
    tell application "System Events" to click (first button whose value of attribute "AXDescription" is "exit to Desktop 4") of list 2 of group 1 of process "Dock"
    delay 0.5

    tell application "Google Chrome"
    	activate
    	tell application "System Events"
    		tell process "Google Chrome"
    			click menu item "Distractions" of menu 1 of menu bar item "People" of menu bar 1
    		end tell
    	end tell
    end tell

    do shell script "/Applications/Mission\\ Control.app/Contents/MacOS/Mission\\ Control"
    delay 0.5
    tell application "System Events" to click (first button whose value of attribute "AXDescription" is "exit to Desktop 5") of list 2 of group 1 of process "Dock"
    delay 0.5

    tell application "Messages"
    	activate
    end tell

    tell application "HipChat"
    	activate
    end tell

    tell application "Telegram"
    	activate
    end tell


    do shell script "/Applications/Mission\\ Control.app/Contents/MacOS/Mission\\ Control"
    delay 0.5
    tell application "System Events" to click (first button whose value of attribute "AXDescription" is "exit to Desktop 1") of list 1 of group 1 of process "Dock"
    delay 0.5

    tell application "Omnifocus"
    	activate
    end tell

    tell application "YNAB"
    	activate
    end tell

    tell application "Sunrise"
    	activate
    end tell

	return input
end run

Before I break down this script, let me tell you a little bit about my setup. I have dual 27” HDMI displays. The first display has 3 spaces and the second display has 2 spaces. On Desktop 1, I keep all my “productivity” apps. (The quotes are because I am very easily distracted by these apps if they are always running). These include apps like YNAB, Sunrise Calendar, and Omnifocus. Desktop 2 is my workspace. I usually have iTerm2 and IntelliJ running on this desktop. Desktop 3 is a scratch space for apps I fire up and tear down quickly. Desktop 4 is for my browsers. And Desktop 5 is for my messaging apps, like Messages, Telegram and Hipchat.

Part of what I wanted to accomplish in this automation was having the apps launched on the correct space. Lines 3 - 6 in the code block above accomplish this. Line 3 gets us into Mission Control. Line 5 clicks on the appropriate Desktop. In this case, Desktop 4.

Once I am on Desktop 4, I can launch my Distractions Google Chrome persona, which is what lines 8 - 15 does.

Next, I switch to Desktop 5 and launch my messaging apps.

And, finally, I switch to Desktop 1 and launch my productivity apps.

I also bound the key sequence:

CTRL+ALT+CMD+]

to toggle Do Not Disturb mode.

Now, just before I start a pomodoro, I hit:

CTRL+ALT+CMD+,
CTRL+ALT+CMD+]

And, when I am in the pomodoro break, I hit:

CTRL+ALT+CMD+.
CTRL+ALT+CMD+]

During my testing of these scripts, I had to add certain applications to a list of applications allowed to interact with the Accessibility features of OS X. I probably should have kept better track, but it included Automator and Google Chrome.

I started looking into toggling Do Not Disturb mode as part of the key sequence for open and close distractions, but I bailed on that. I also started to look into hooking into SizeUp so that I could lay out the messaging windows the way I like as part of the open distractions script, but I bailed on that too. Getting to the point I am at - which is very functional - took about an hour of Googling and experimentation.

Any feedback on how to make it more awesome or to correct any bone-headed things I am doing is much appreciated.

Pomodoro & HipChat: Automate Availability

Mon, 19 Aug 2013 06:33:41 +0000

The Pomodoro Technique is a way to enhance focus while working. There is a high cost in brainpower to stop doing what you are focused on, look at the tweet that just came in, and then try to start up where you left off. The idea of working in “pomodoros” is that you work uninterrupted for 25 minutes. Then you get a 5 minute break. After you do 4 of those cycles, you get a 10 minute break. Speaking from my own experience, I get a lot more done in 4 hours of pomodoros than 8 hours of work disrupted by various notifications.

At Work Market, we rely on HipChat to communicate with each other throughout the day. This is a very handy way to connect our two offices and the various remote workers that we may have at any given time. However, when I am in a pomodoro, I don’t want to be disturbed by HipChat.

Following the excellent post here, I am able to automatically set my status to “Do Not Disturb” when I start a pomodoro and back to “Available” when the pomodoro is done.

I’ve taken it one step further by sending a notification to the main room we all use in HipChat to let my coworkers know what I am up to. This is a little more communicative than just having my status abruptly change with no other context.

The key is making use of the HipChat API in conjunction with AppleScript.

Firstly, I created a shell script named HipChat.Pomodoro.sh that takes a message as an argument and sends it to the specified HipChat room using the API:

1
2
3
4
5
6
7
8
#! /bin/bash
ROOM_ID=[HipChat Room ID]
AUTH_TOKEN=[HipChat Auth Token]
MESSAGE=$1
curl -s \
  -d "room_id=$ROOM_ID&from=Pomodoro&notify=1&color=yellow&message_format=text" \
  --data-urlencode "message=(pomodoro) $MESSAGE" \
  https://api.hipchat.com/v1/rooms/message?auth_token=$AUTH_TOKEN > /dev/null

You’ll need to put in your own room id and auth token from HipChat.

You can test this right from the command line:

./HipChat.Pomodoro.sh "Test Message"

Next, I updated the settings in the Pomodoro app preferences to make use of the script:

I added the call to my script after the AppleScript from Sean’s original post. I have the Start, Interrupt Over, Reset and End events handled

Start:

1
2
3
4
5
6
7
tell application "System Events" to tell UI element "HipChat" of list 1 of process "Dock"
  perform action "AXShowMenu"
  delay 0.5
  click menu item "Status" of menu 1
  click menu item "Do Not Disturb" of menu 1 of menu item "Status" of menu 1
end tell
do shell script "/Users/dogeared/Hipchat.Pomodoro.sh 'Micah is starting a Pomodoro. He will be back in 25 minutes.'"

Interrupt Over:

1
2
3
4
5
6
7
tell application "System Events" to tell UI element "HipChat" of list 1 of process "Dock"
  perform action "AXShowMenu"
  delay 0.5
  click menu item "Status" of menu 1
  click menu item "Available" of menu 1 of menu item "Status" of menu 1
end tell
do shell script "/Users/dogeared/HipChat.Pomodoro.sh 'Too many distractions. (pomodoro) fail for Micah!'"

Reset:

1
2
3
4
5
6
7
tell application "System Events" to tell UI element "HipChat" of list 1 of process "Dock"
  perform action "AXShowMenu"
  delay 0.5
  click menu item "Status" of menu 1
  click menu item "Available" of menu 1 of menu item "Status" of menu 1
end tell
do shell script "/Users/dogeared/HipChat.Pomodoro.sh 'Micah bailed! (timeforthat)'"

End:

1
2
3
4
5
6
7
tell application "System Events" to tell UI element "HipChat" of list 1 of process "Dock"
  perform action "AXShowMenu"
  delay 0.5
  click menu item "Status" of menu 1
  click menu item "Available" of menu 1 of menu item "Status" of menu 1
end tell
do shell script "/Users/dogeared/HipChat.Pomodoro.sh 'And... Micah is back! (thumbsup)'"

Note: The Pomodoro app’s script tab in preferences is finicky. The standard copy-and-paste shortcut keys do not work, but right-clicking and choosing copy or paste does work.

You will need to enable access for assistive devices in System Preferences -> Accessibility in order for the Pomodoro automation to work.

Here are some screenshots from HipChat. In the first one, I started a pomodoro and reset in the middle of it. The second one shows a complete pomodoro.

Weekend Project: Fix Dark Tower

Sun, 16 Oct 2011 20:52:41 +0000

This post is about replacing the keypad on the game Dark Tower. If you're not interested in my nostalgic blathering, click here to get right to the instructions.

Nostalgic Blathering

For those of you not familiar (because you're too young or live under a rock), Dark Tower was one of the first interactive electronic board games that was massed produced. It was released in 1981 and I got one for my 13th birthday. It blew my mind - not only because it was fun to play - but because of the possibilities that electronics could bring to gaming. I had been hacking around on Pet computers for about 2 years by that point. While there were some character based green-screen games for the Pet, Dark Tower was the first mixed media game I had ever played. You set up a physical map board, complete with plastic buildings, flags and character pieces. You monitored your progress through the game with a cardboard status indicator which used re-purposed battleship red peg markers. On the peg board, you kept track of how many warriors, gold, food, keys and other items you had during game play. At the center of it all was the Dark Tower. It sported a 12 button keypad and a display that tells you what had happened on each turn of the game. Display is a generous word in this context as it really was just a vertical row of three lights behind a plastic drum with pictures. The drum turned to the correct position and the correct light illuminated behind the relevant picture for what just occurred in the game. The game came in a huge cardboard box with artwork on it that fit right in with the Dungeons & Dragons mindset of the early '80s.

The Keypad Problem

Complete Dark Tower game sets in good working condition go for as much as $400 on Ebay these days (average price is probably $100). Back In 2003, my brother bought me a complete working Dark Tower set from an antique shop in New York City for my 35th Birthday. My brother, sister and I (as well as others) played the hell out of the game for 2 years before the keypad crapped out. The original keypad was constructed of 3 thin plastic sheets (see pictures below). Two of the sheets have metal contacts and are separated from each other by a blank plastic sheet with holes in it. When you press a "key", the two metal contacts touch through the plastic sheet in the metal. Although pretty tough, it is this simple construction that tends to wear out first on these games.

When my siblings and I got together, we always had a hankering to play Dark Tower. So, we decided to try to fix the keypad. With a little copper tape and one solder joint, we were able to get the keypad working again. This fix lasted us another eight years - pretty good for our MacGyver-like fix. At a recent company game night, the keypad crapped out again in the middle of a game. This was after I had introduced the game to a bunch of twenty-somethings who had never heard of it before and who were enjoying it quite a lot. I thought, "This shall not stand, man!" That thought was quickly replaced with a "WTF" as I looked online and found Dark Tower repairs costing $70 - $100. Thankfully, I have been given the gift (and curse) of being a compulsive tinkerer and DIYer.

This weekend with the help of Adafruit.com's keypad (2 of them - 1 had to be sacrificed so you wouldn't have to), some scribbled notes, some nail-biting-trimming of said keypad with a scissor and a wire wrapping tool, my brother and I completely replaced the keypad and have a fully functional Dark Tower again. As an added bonus, the Adafruit keypad has a satisfying click when pressed - a feature missing from the 1980s pure membrane keypad. While I had hoped I would be able to simply plug in this new keypad, the universe laughed. If you want to skip the background on how these keypads work and just get to the steps, click here.

How Membrane Keypads work

For a 12-button keypad, you only need seven pins to determine which key was pressed (3 columns and 4 rows). Each key press combines two of the seven pins when contact is made. When I first hooked up the new keypad, I quickly realized that the pin mappings were very different as almost none of the keys worked. This is the reason that I bought two of the Adafruit keypads. I ripped one of them apart so that I could see exactly how each of the keys connected to the pins. I was able to do the same for the original keypad, which was pretty much toast anyway. I'm going to refer to the original keypad by number, just like the new keypad has and just like a standard telephone dialing keypad has.

Key: (x,y) <========= pins
       z   <========= number on keypad

          Old Keypad                        New Keypad
=============================     =============================
| (5,2)     (4,2)     (3,2) |     | (3,7)     (2,7)     (1,7) |
|   1         2         3   |     |   1         2         3   |
|                           |     |                           |
| (5,1)     (4,1)     (3,1) |     | (3,6)     (2,6)     (1,6) |
|   4         5         6   |     |   4         5         6   |
|                           |     |                           |
| (5,6)     (4,6)     (3,6) |     | (3,5)     (2,5)     (1,5) |
|   7         8         9   |     |   7         8         9   |
|                           |     |                           |
| (5,7)     (4,7)     (3,7) |     | (3,4)     (2,4)     (1,4) |
|   *         0         #   |     |   *         0         #   |
=============================     =============================

Cable Pin Mappings

With the two pin maps above, I could now create a cable to properly connect the new keypad to the internal connector of the Dark Tower. Here is the pin map:

 DT Connector     New Keypad
   1 =============== 6
   2 =============== 7
   3 =============== 1
   4 =============== 2
   5 =============== 3
   6 =============== 5
   7 =============== 4

NOTE: I arbitrarily chose “pin 1” to be the top of the internal connector with the Dark Tower laying on its side as pictured below.

Here are pictures of the two keypads, closed, open, and with pin explanations:

Test Run: prototype

The first thing I wanted to do was test out my pin mappings. I used relatively heavy gauge wire connect the new keypad to the connector in the Dark Tower using the mappings above.

And… it worked!

Make the Cable

The new keypads each came with a 7 pin header. I thought I would simply solder wires to the headers in the appropriate order outlined above, and then plug one end into the socket in the Dark Tower and the other end into the keypad. Sadly, the universe laughed again. My soldering skills are adequate at best. What I had forgotten is that the pins on these headers are meant to break away. That way, you can have a 2-pin header or a 10-pin header - whatever you need. As I began soldering the first wire onto the first pin, the heat melted the connecting plastic in the middle and the pin just fell off from the rest of the bunch. No to be deterred, I remembered that I in my college days, I used a super handy wire wrapping tool and very thin wrapping wire. This tool made it very easy for the lazy and soldering inept (me, basically) to still put together complex projects involving connecting up electronic components without having to solder them. One issue I found with wire wrapping on the square pins of the header was that it is easy to break the wire if you're not careful. After a few attempts, I got the technique down, which involves wrapping a little more slowly and moving the wrapping tool out as you wrap. I built my cable, but you can see that for the 7th pin, I used a bit of heavier gauge wire since I had destroyed the original pin from the header.

Test Run: for realz

The next step was to test to the cable in the Dark Tower:

And… it failed. The first time it failed because I had screwed up the pin connections. The second header only having 6 pins threw me off (pictured above is the final working cable). I re-wrapped all the wires (so much easier than de-soldering!) and tried again. This time, all of the keys worked except the bottom row. The reason for this, we found, was that pin 7 was not making good contact in the connector on the Dark Tower (hey, the thing’s 30 years old - cut it some slack). Jamming a small piece of the heavier gauge wire in with the header on pin 7 got it working. I realized that I needed to ensure that the header wouldn’t fall out of the internal connector. I thought about gluing it in, but I wanted a less permanent solution. So, I jammed small pieces of the heavier gauge wire in at pin 1 and pin 3 on the internal connector. We’ll see how this holds up long term. I may need to come up with a better solution for keeping the cable plugged in internally. (After the picture below was taken, I trimmed the bits of wire so there is no exposed copper).

In order for the keypad to fit back into the dark tower, I had to trim it. I did this by measuring against the plastic bezel that it sits in and by holding the keypad up to a bright light to ensure that I would not be cutting through any of the traces. I then put electrical tape carefully around the exposed header pins on my cable. I needed to put the original keypad decal on top of the new keypad and to put the whole together with the plastic bezel. I thought about using adhesives, but since the whole thing is held in with a fitted plastic outline from the bottom, I decided to just layer everything and let the pressure hold it together. This way, if any future adjustments need to be made, I won’t have to damage anything getting it apart again.

Closing Time

It was finally time to close the patient up. The bottom of the new keypad could not be trimmed at all since all the traces connect there. By trimming the top, I was able to at least make it flush with the bottom of the Dark Tower. This resulted in a slight warping of the outer tower once assembled and there is some pressure being put on the ribbon cable, but neither of those issues are show stoppers.

Once everything was closed up, we did another test where we exercised all the keys. Everything worked great. The tactile feedback of a click when a key is pressed is great. The keys are not 100% lined up with the original overlay, but it’s close enough that neither my brother, nephew or I hit the wrong key by mistake when we played. Here, you can see me spanking some Brigands.

DIY Satisfaction

So, for $12.06 in parts from Adafruit (includes 2 keypads, tax and shipping) and $11.60 in parts from Radio Shack (the wire wrap tool and the wrapping wire - which I will use again), I was able to bring back to life a classic (and favorite) game. I’ll be bringing it back to game night in November at work and we should be able to get a full game in this time!

Parts List and tools

Adafruit keypad
Wire wrapping tool
Wrapping wire
electrical tape
scissors
Philips head screwdriver </ul>