I figured now was as good a time as any to finally set something up to make it more convenient. I ended up using a Raspberry Pi Zero W set up in the hallway to send IR commands to the receiver. It hosts a REST API and React frontend on the local network so anyone on the network can operate the skylights. All of the gory technical details can be found on GitHub.

Overall I’m very happy with how everything turned out. It was fun working in a different environment with different tools and constraints. Of course, the process was far from smooth because most of the docs around the IR shield and LIRC were out of date due to some changes in the kernel last year. I ended up not using LIRC and recorded/replayed raw IR signals using gpio-ir directly which works great for my use case but potentially not for others.

So now I had a REST API and frontend but I wanted it to be even easier to control via my phone. I discovered HTTP Request Shortcuts which allows you to configure home screen shortcuts to send HTTP requests. It was super easy to set up and has been working flawlessly ever since. Well, it was very straightforward but was still tedious to type in HTTP requests on a phone keyboard.

The final piece of the puzzle was connecting it to my phone alarm so the shade will open when my alarm goes off in the morning. My original plan was to run something on the Pi to poll for alarms from my Google account but I was unable to find an API to list alarms. As far as I know they are synced somewhere but it may be as Android application data rather than an official user facing Google API.

I instead found Tasker which is a general purpose Android automation app. Setting up the HTTP requests was straightforward just like the app shortcuts. However, I had a lot of difficulty with the alarm integration. I selected what sounded like the correct trigger for an alarm but it didn’t work. I tried a few other alarm triggers just in case but those didn’t work either.

This is where things get pretty fuzzy because I didn’t do a very deep dive on Tasker. Eventually I stumbled upon AutoAlarm which is a Tasker plugin that allows you to set a global variable with the time of the next alarm. That imported a very lengthy Tasker task to keep the variables up to date but I quickly discovered that it doesn’t unset it when the alarm is disabled. I worked around that by running the task periodically to reset things in case the alarm was disabled or an update was missed somehow. Finally, this allowed me to close the loop and open the skylight when my alarm goes off!

However, this isn’t without its shortcomings. First, while Tasker is a very full featured and flexible app, the user interface was infuriating. There were many unintuitive interactions all over the app e.g. the back button pops a Toast rather than going back so you have to find the back button on the top right of the app. All the while, there were near constant modals with tips and warnings about settings that I should change e.g. turn off battery saver, no active profiles, notifications prompting the user to disable them entirely. I understand that this is a power user app but it still makes me appreciate the polish on the apps I use day to day.

My final gripe with Tasker is that the OS constantly displays an alarm for some time in the future even when I don’t have one enabled. It’s often exactly 10 minutes in the future and updates as time ticks on which makes me think that it’s how Tasker does some of the alarm based triggers.

All of these issues gives me the feeling that it’s all held together by shoestrings and can fall apart at any time. Also, Tasker feels like a supercharged V12 engine which is significantly overpowered for my needs. I can only assume that it has negatively impacted my battery usage but I don’t have any evidence to back this up.

I’m pretty happy with how everything turned out. The Raspberry Pi was super great. Sending IR commands took some trial and error but it’s now working out very well. Setting up the REST API was super straightforward. I enjoyed using React for this project but was disappointed by several aspects of it coming from Vue. The Android alarm integration is by far the least successful part of the project so that could use some work eventually.

It’s all open source so feel free to tweak it to suit your needs!

class Animal():
    def sound(self):
        raise NotImplementedError()


class Dog(Animal):
    def sound(self):
        return 'woof'


class Cat(Animal):
    def sound(self):
        return 'meow'


class Fox(Animal):
    def sound(self):
        return 'ring-ding-ding-ding-dingeringeding'


for animal in [Dog(), Cat(), Fox()]:
    print(animal.sound())

I’ll spare you the example implementation but also remember the classic Car base class with abstract wheelCount() and doorCount() methods for derived classes to implement.

A programmer might understand how these classes behave and reason through code using them but still not understand when polymorphism should be used. In fact, this is a bad use of polymorphism. A better implementation would merely have a single class with member variables to capture the relevant information along with factory functions to create common instances of them:

class Animal():
    def __init__(self, sound):
        self.sound = sound

    def sound(self):
        return self.sound


def Dog():
    return Animal('woof')


def Cat():
    return Animal('meow')


def Fox():
    return Animal('ring-ding-ding-ding-dingeringeding')


for animal in [Dog(), Cat(), Fox()]:
    print(animal.sound())

An enum with singletons for the necessary instances would also be a good choice but you get the idea.

So what is a good example of polymorphism? Something that actually requires different code to run rather than only different data:

class ChatChannel():
    def send_message(self, message):
        raise NotImplementedError()


import slack


class SlackChannel(ChatChannel):
    def __init__(self, channel):
        self.channel = channel

    def send_message(self, message):
        slack.send_message(self.channel, message)


import hipchat


class HipChatChannel(ChatChannel):
    def __init__(self, channel):
        if channel.startswith('@'):
            self.is_user = True
            self.channel = channel.lstrip('@')
        else:
            self.is_user = False
            self.channel = channel.lstrip('#')

    def send_message(self, message):
        if self.is_user:
            hipchat.send_user_message(self.channel, message)
        else:
            hipchat.send_channel_message(self.channel, message)


channels = [
    SlackChannel('#general'),
    SlackChannel('@alice'),
    HipChatChannel('#random'),
    HipChatChannel('@bob'),
]

for channel in channels:
    channel.send_message('Hello World!')

This example has a ChatChannel class which is implemented by SlackChannel and HipChatChannel. SlackChannel uses the slack library to send a message while HipChatChannel uses the hipchat library and has some special handling for users and channels. The different library dependencies and logic is something that you can’t do with pure data like in the revised Animal example. You could do it by passing in a lambda, storing it as a member variable, and calling that to send the message. However, that’s just hand rolled virtual dispatch at which point you’re better off using proper inheritance for it.

All of this is not to say that the Animal example shouldn’t be used at all! It can be useful to demonstrate the concept in a very basic way but the conversation should quickly move to more motivational examples to help explain when polymorphism should and should not be used.

Oddly enough, this weird system lines up nicely with 24-hour time (military time). Other than 00:00 and 12AM, the times match if you subtract 12 hours from the PM times. This is awfully convenient for programmers when looking at log files because the conversion is very straightforward. Although, there is often a time zone offset to account for which gums up the works.

So in some sense, our hours are 0-indexed because 01:00 is the second hour rather than the first. And now returning to the clock in my car, they most likely decided to 1-index it to make the spec as simple as “count from 1 to 12 and loop around.”

Anyway, time is hard and I should probably buy a new car.

This script doesn’t have many miles under its belt but it has worked well for me a few times so I hope it works for you too!

The holy grail is doing both strategic and tactical programming. The trick is to find the boundaries where you need to change your mindset from one to the other. Things that are hard to change should be done strategically because changing them can have rippling effects on other components whose changes and deployment might need to be done in lockstep.

Some examples of things to do strategically:

• APIs: Changing any public API ranges from hard to impossible because many of the clients could be entirely out of your control and even unaware to you. REST API endpoints, public methods in code, network protocols, environment variables, and command line arguments come to mind.
• Data formats: Data formats are a kind of public API but with some extra caveats. When changing the data format you would ideally do it in a backwards compatible way. When making backwards incompatible changes you can must choose to maintain code to deal with the old format, bite the bullet and migrate all existing data into the new format, or decide to entirely drop support for old data. Database migrations can be particularly cumbersome. Even when you control the only client using the database, you’ll often have to do a staged rollout to avoid downtime or data in an inconsistent state. Database schemas and file formats are the obvious examples.

The flip side of this is all of the things that we can afford to do tactically! Fortunately, strong APIs provide encapsulation which allow us to hide implementation details behind the facade of the public interface. We can be less thoughtful when it comes to internal choices such as data structures, algorithms, code style, and even choice of programming language and framework. We can leverage tools like Docker and OpenAPI to encapsulate the dirty details inside.

These ideas are powerful because you can get the best of both worlds. Spend time on the things that are hard to change and spend much less time on the things that can easily be improved in the future. This results in a significant time savings when you never end up making those further improvements down the line or, in extreme cases, scrap the entire thing. Depending on the project, this is a likely outcome. However, you still need to be careful not to over-architect the public API because even those choices can take a lot of time.

I’ve found myself using these principles to great effect during code reviews. I’m much more lenient when it comes to things like local variable names, algorithms, HTML structure, and command line scripts and refrain from making nitpicky comments that result in more time wasted than the theoretical benefit they would provide. Most frontend programming falls into this category. Other than URL structure and cookies, frontend code in general just needs to be internally consistent which is great news because Typescript, refactoring tools, and unit tests make it easy to be confident when making these types of changes.

As always, I’m still working on honing my skills in this area to be more effective. Thanks for the interesting read, Ben!

What was different about these apps?

I tried reinstalling dependencies, starting from scratch, etc. but to no avail. Eventually I decided that it must be my node/npm/yarn install so I set out to nuke it from my system and install it from scratch.

I was a little disappointed that there didn’t appear to be any equivalent to npm uninstall -g everything. There were some scary looking bash commands that claimed to clean everything up but I didn’t want anything to go astray so I opted to do it by hand instead.

Things were fine at first when I started running sudo rm -rf /usr/local/lib/node and sudo rm -rf ~/.yarn. I then found /usr/lib/npm/node_modules and inspected its contents with ls. I quickly modified the previous command by putting sudo rm -rf at the beginning and backspaced a little to far to leave /usr/lib at the end and hit Enter.

$ sudo rm -rf /usr/lib

Oops.

There was no prompt for sudo password because I had already been running commands under sudo. As soon as I realized what I had done (about half a second), I mashed Ctrl-C a few times. Phew. It must okay, right? I mean, how much damage could that have caused?

I ran ls /usr/lib and saw a few broken symlinks. Well, maybe I can just reinstall that package and things’ll be fine.

$ sudo apt-get update
sudo: unknown uid xxxxxxx: who are you?

Hmm, not a good sign. Well, maybe I can copy the relevant files from a coworker and that’ll be good enough. Oh wait, I can’t do that without root/sudo.

At this point I accepted that the machine was more or less a lost cause so I had to go into recovery mode and get it ready for imaging. Fortunately, /home was on a different drive entirely so I only had to worry about system configuration. I figured that /etc/, /var/, and /opt/ would be a good start so I inserted a flash drive and tried to mount it but quickly realized I couldn’t do that without root. Well, let’s just copy those to my home directory then. Not so fast - you need root to be able to read most of those files.

This seemed like as good a time as any to call it a night and go home.

In the morning, I got the machine reimaged, discovered that my home directory was on a RAID1 array, reassembled said RAID array, mounted it over /home/, and I was off to the races! I had the usual set backs one would expect and slowly installed the necessary packages to start working e.g. git, tmux, vim.

Okay, what was I doing before? Right, trying to run a barebones Vue app. I installed node and yarn from scratch and tried creating the app again.

$ yarn serve
/bin/sh: vue-cli-service: command not found

What?!

At this point I was baffled. I started modifying the scripts in package.json to debug it. It turns out that yarn serve adds some directories to $PATH so binaries in installed packages can be called by name e.g. $(pwd)/node_modules/.bin. It just so happened that I was testing these apps in temporary directories that are made with a bash function:

function cd_temp {
   local name; name="${1:-default}"
   local date; date=$(date "+%Y-%m-%d.%H:%M:%S")
   local template; template="${date}_${name}_XXX"

   if [ "$(uname)" = "Darwin" ]; then
       cd "$(mktemp -d -t "$template")"
   else
       cd "$(mktemp --tmpdir --directory "$template")"
   fi
}

You might notice that the template for the directory has two : characters in it. You might remember that : is the character used as the separator in $PATH so rather than adding the current directory to the path it ended up adding a bunch of gibberish to the path. No wonder it couldn’t find vue-cli-service!

Sure enough, I changed the function to not use : in the template and everything worked.

Ultimately, this wasn’t a huge set back with all things considered. I was back up and running in a few hours and during that time I was still somewhat productive without a functional desktop by responding to emails/Slack/etc. There are definitely some takeaways, though:

• Tools should have an easy way to uninstall the packages that they maintain e.g. yarn/npm.
• Be careful when running any command that starts with sudo rm -rf /.
• Make sure that you backup important data in case you need to recover it or start from scratch.

Programmers like to write code and view anything other than writing code as unproductive time. “I only actually write code 20 hours a week.” “That project took 10 hours but I only spent a few hours actually writing code.”

It’s understandable because that’s what we’re trained to do and shipping code is generally the “useful output” that is valuable to the company and customers.

However, technical challenges surrounding programming tasks are often necessary evils. The article that prompted this one in particular described the battle between JavaScript libraries and clashing CSS. Sure - spending a few hours getting that sorted out is unfortunate but it likely far outweighs the cost of implementation without leveraging those libraries. Docker giving you problems? You have to learn its idiosyncrasies and play along if you want the isolation and reproducibility that it offers. What about wanting hermetic builds from Bazel but struggling to shoehorn your project into its prescriptive worldview? It’s up to you to decide if the benefits outweigh the downsides.

As for a professional software engineer, there are plenty of important things to do that are not actually writing code: documentation, code review, design docs, project planning/scheduling, and performance reviews to name a few. With any luck, these tasks will be an efficient and worthwhile use of time.

No Silver Bullet discusses how there won’t be single breakthrough in computing that results in an order of magnitude increase in productivity, performance, efficiency, etc. Libraries, languages, frameworks, and the like yield modest yet significant results in some of those categories. However, they sometimes result in less time actually writing code because more of the work has been shifted into installing, configuring, and generally understanding how to use these tools. And that’s okay. The end goal isn’t to write more code - the code is merely a means to an end. Shipping a product and solving a customer’s problem is the end goal. I haven’t been in the game very long but it appears that over time programming has moved to more of a plumbing job in that you need to find compatible parts and put them together in a particular way to solve the problem at hand. Even visual programming removes the need to actually write any code because it’s just clicking and dragging boxes and lines around yet you can still solve some real problems.

I don’t mean to imply that struggling with tools is a necessary evil and we shouldn’t try to fix it - quite the opposite in fact. Better tools, development environments, and libraries are accelerating the rate of development like never before and result in better products so we should continue to make them better. Productivity should be measured more on how much of a problem is solved in a given amount of time not how much of it is spent actually writing code or how many lines of code were written. It’s often much much easier to solve a problem by coming up with a better and more pragmatic solution rather than immediately jumping into the code when the first solution presents itself.

So stop being so concerned about not actually writing code - it’s sometimes a better use of your time.

I find this endlessly intriguing. What is their relationship with video games? Do they game after “work”? How do they feel about their lives being broadcast to so many people? How much of their personal life do they divulge? Do they worry about people seeing their eating, dressing, and bathroom habits?

I recently rewatched The Truman Show. Besides being a very enjoyable movie, it has thought provoking commentary on social media today and, being released in 1998, was ahead of its time. There is a fantastic Nerdwriter video about it which I highly recommend.

I can’t help but see the parallels between streamers on Twitch.tv and The Truman Show. The most obvious being a window into someone else’s life.

The platform makes it trivial to have a constant video stream of whatever you choose. The Truman Show, specifically the fake show inside the movie, was a massive production but it doesn’t have to be to get a similar effect. I wouldn’t be at all surprised if there is a stream emulating The Truman Show because the barrier to entry is so low these days. Probably not of a person against their will but very likely of a pet who is none the wiser.

Perhaps the most interesting parallel is advertising because it’s already happening to some degree. Meryl Burbank, Truman’s wife, often advertises directly to a camera while in the same room as Truman. This is effective because it is embedded into the content and there are lots of eyeballs on the screen. This differs from traditional advertising in that the advertisements are in a distinct section compared to the content. This has a severe disadvantage because we have all learned to ignore this type of advertising.

Streamers can be sponsored by companies and brand their stream. They can get more subtle by getting paid to casually mention a product during their stream. Or get even more subtle by showing a branded coffee mug to the webcam.

I’d imagine this would be super effective because the streamers have 1000’s of subscribers and a very particular audience and I’m surprised that this isn’t more common.

Vitamix

The Vitamix blender has won many awards and it doesn’t need repeating that it’s a great and versatile kitchen appliance. I have the 5300 model but they all appear to be pretty comparable as far as I can tell. What I like the most about it is how simple yet effective it is.

Let’s consider the Oster 6811 blender. It has 12 different settings: pulse, pulse, grate, easy clean, blend, puree, shred, cream, grind, chop, liquefy, whip, ice crush, and mix. Phew. I don’t know about you, but I don’t know when I would use some of those settings rather than other ones and the sheer number of options is dizzying.

Or how about the Blendtec TB-621-20? It certainly has fewer options than the Oster but there are only icons on the buttons so it’s unclear to me what each one does. Also, the -/+ buttons operate in addition to the different modes?

Finally, let’s move on to the Vitamix. It has a start/stop toggle, hold for pulse switch, and 1-10 speed knob. It’s pretty clear from the get-go that you flip it on, crank the knob to the desired speed, and turn it off when it’s done. It is great at what it does so it doesn’t require any features to persuade people to buy it. The product speaks for itself.

Granted, some of the other settings could come in handy from time to time and the price point of each product should be considered as well. I very much appreciate the simplicity of the Vitamix and how you know what is going to happen when you flip it on.

Sonicare

The Philips Sonicare Diamond toothbrush is another elegant and effective product. It is “just a toothbrush” yet the attention to detail is impressive.

There is a single button on the device that is used to turn it on, change modes if it was recently turned on, and turn it off. The conductive charging technology provides lots of benefits:

• Charging is easier than plugging a cable into it (just plunk it down in the charging stand!)
• Waterproof because there aren’t any exposed ports
• The toothbrush fits nicely in the travel case which is set up with conductive charging just like the stands

It’s a pretty powerful toothbrush and Philips thoughtfully built in a few week ramp up period to slowly increase the power to allow your gums to adjust. The only visual indicator on it is the battery level which is very sleek and elegant.

The brush timer that triggers every 30 seconds to indicate that it’s time to switch sides is clever. The obvious way to do this would be either with a visual indicator or a sound of some sort. A visual indicator is out of the question because you likely can’t see the device when the business end is in your mouth! A sound could work pretty well but would require special hardware in the toothbrush to make that happen. They ended up using haptic feedback by changing the vibration pattern slightly which is very (but not overly) noticeable in one’s mouth.

What the Vitamix and Sonicare have most in common is a simple and reliable design which is important in terms of usability, durability, manufacturing, and maintenance. Although I don’t own one myself, KitchenAid stand mixers are in the same category. They have simple controls, do one thing well, yet are very versatile. All of these qualities make them a joy to use and result in happy customers.

Other companies should take note.

#!/usr/bin/env bash

set -euo pipefail

if [[ $# == 0 || $1 == "-h" || $1 == "--help" ]]; then
    echo "Usage: $0 file"
    exit 0
fi

file="$1"

if [[ $file =~ ^http(s)?:// ]]; then
    temp_file=$(mktemp)
    wget --quiet "$file" --output-document "$temp_file"
    file=$temp_file
fi

if hash pager 2>/dev/null; then
    pager "$file"
else
    less "$file"
fi

This could easily be expanded to support other protocols e.g. (s)ftp://. This script is also in gist form.