EricDaugherty.com

Site Redesign and Migration

Thu, 05 Mar 2026 03:13:01 +0000

My old site design was getting a bit old and it was time for a cleanup. Now that AI is all the rage I used Claude Code to come up with a new site design and applied it.

This is really 2 different sites… www.ericdaugherty.com and blog.ericdaugherty.com. www was hosted via GitHub Pages while blog was hosted using Google’s Blogger. I felt it was time to move to a simpler static blog setup, so I migrated that to Hugo, also hosted by GitHub Pages.

For the www site, I just had to have Claude Code come up with a new design based on my very rough descriptions, and then I iterated on it with Claude until it looked acceptable.

For the blog site, I needed to create a new repository, initialize a Hugo site, import all the blog posts, import the styling from the www site, and then throw them all together and fix any and all of the issues. When I say ‘I needed’, I mean ‘I prompted Claude to…’.

While this is hardly custom software development, my experience with the migration makes me more convinced that I will be using AI as my interface to all things technical. While it wasn’t perfect, especially with tweaking the visual layout, I accomplished the entire process in a few hours of prompting while multi-tasking.

I realized the old site was still using FeedBurner, which has long been abandoned (although still functional), so the Subscribe link now points directly to the index.xml (Hugo’s RSS Feed) as does the Meta header. The old FeedBurner link has been updated to point to that as well.

Let me know if you see any issues. I cleaned up some content and fixed some long-broken images but mostly it is just a fresh coat of paint and a new home.

Portable Power Pricing (or how I built something with AI)

Sat, 21 Feb 2026 23:47:00 +0000

In my recent blog post Surviving the Great PSPS of 2025, I outlined my interest in Portable Solar Generators, and I've been looking for a side project to test out the latest AI capabilities. I found the answer in PortablePowerPricing.com

I was recently looking to buy an additional battery for my EcoFlow Delta 2 Max, but since all of these products are nearly always sold at a significant discount to their MSRP, I wasn't really sure how good of a deal it was. There are existing price trackers, but I realized there was another interesting aspect here. I wasn't just looking for the best price, but for the best price per Watt hour (Wh). I realized there was an opportunity to build a price comparison site specifically for this product category.

I primarily develop in VS Code using devcontainers, so that's what I did for this project. I ended up with 2 different projects, one to crawl the sites to get prices, and one for the public website. Each was a separate VS Code project (devcontainer) and git repo. I used Claude Code (Opus 4.5 and 4.6) via the VS Code plugin. I used the Claude Code Max (5x, $100/month) subscription, and only ran out of quota once during the project.

Throughout this project, I didn't write any code, or build any config files. I made some very minor edits by hand on occasion, but Claude Code wrote almost every line of every file in both projects.

I won't go through every step in the process, but I did want to highlight a few experiences and learnings...

Price Discovery

Clearly a key aspect of this is capturing the prices for each product and documenting their changes over time. I started by asking Claude about potential tools for this, and it ended up recommending PriceGhost. This is a pretty new project that was also built almost entirely with AI. I liked the pitch that it could use AI to help figure out the right price instead of leveraging the 'old school' approaches of parsing ever changing HTML pages.

It worked fine for a little while, but as I added more sites and more pages I ran into issues. One was that this is a new project and the code isn't really battle tested. I had to fork the project and make some changes (I submitted a PR) to get it to work for some pages where the title was too long, but for others it just wouldn't work at all. I also found that the AI aspect of it wasn't really effective. I was using Ollama as my model, but it would not reliably find the right price on the page.

I went back to Claude and discussed the challenges and we ended up settling on ChangeDetection.io. This is a more established and traditional tool, but Claude told me that most (all?) of the sites I would be scraping used Shopify and we could often just pull the JSON file for each product and easily get the product without parsing HTML.

But the real magic here was having Claude write a script that would automatically setup the watches for me. It queried my production database, found the URLs of each product, used the ChangeDetection API to create a watch, and then updated the production database with the watch's ID so I could sync the prices.

This is the kind of script that I could always write, but Claude Code did it in ~ 30 seconds and could make any changes needed to update, etc.

But the real long term issue here is how difficult will it be to maintain the price scraping functionality? As a non-revenue generating side project, I will only have so much patience and it isn't quite so automated that I can just ignore it. That was the promise of PriceGhost but it isn't really there yet.

Product Discovery

The most surprising discovery in this project was using Claude to build up the list of brands, products, and product relationships (which expansion batteries worked with which base stations). This is where the whole project would have fallen apart without AI. Realistically, I would not have spent the time to collect and format this information. It would have taken quite a few hours, and it is boring, mostly mindless work that is not justified for a side project.

However, it was not perfect. I did discover a few minor issues it made, but it was able to self-correct them and do additional research instead of me having to go manually fix them.

But this is where I really burned the tokens. Having Claude research websites and generate the product listings was very intense, and initially I would only add one brand per coding session. It often took >25% of my quota to research a single brand. In hindsight, I wonder if I should have used Sonnet for these tasks.

The one time I did run out of tokens was when I had it research all of the brands and fix any mistakes it made, which it did do, but ran through the full quota.

Coding

Writing the code for the project was really the least surprising and interesting part. It is a pretty vanilla Next.JS app that uses Server Side Rendering (SSR) to query the data and build out the static content. I had no real issues getting it to build the pages I wanted, and each feature I added pretty much worked without issue.

While I expected this to be the largest section of learnings and revelations, it was really just straight forward. I used Plan Mode to outline and iterate on each feature I wanted to add, and then once it was correct Claude Code just built it out without issue.

I could have used projects like Spec Kit to manage the requirements and features, and I'd like to explore something like that for a future project, but for the scope of this project it was unnecessary.

Deployment

As a side project, I didn't want to spend a lot of money hosting this, but I did want to put it out in the world, so I asked Claude about the best options for 'free' plans and settled on Supabase and Vercel. Claude walked me through the whole process of setting the accounts and deploying the projects. Going from running locally to fully deployed in the cloud took less than 30 minutes.

I did pony up some cash for a real domain, in case it actually becomes something.

Conclusion

While I embarked on this project to get more hands on experience using Claude Code to write custom software, the biggest surprise I found was how useful it was automating data collection and data entry tasks. Those are the kinds of things that cause a project like this to be abandoned because the 'fun part' is over and there is just 'work' left. Instead, the project remained interesting and enjoyable all the way through.

That said, I was still pretty impressed with its ability to write code. For green field side projects like this, I really don't see myself hand writing code anymore.

I also did discover another similar project called WhichWatts, which seems like a more established and more feature complete version. It has also gone through the effort to commercialize it using Affiliate links. Although I do think my addition of comparing bundles (Base + additional battery combinations) makes it easier to compare target capacity by $/Wh.

That does bring up an interesting final point. I think the cost to build a site like this is going to go down dramatically, but the effort to maintain and commercialize it will still exist. I expect we'll see a lot of cool software get built but abandoned because it will be too niche to justify the ongoing effort. That's always been true to a degree, I think it will just accelerate.

Note: This post was written by a human, with editing feedback from Claude.

JVC Projector HDMI CEC Control

Sat, 03 Jan 2026 20:06:00 +0000

I recently upgraded my projector to a 4k JVC model along with an upgraded AV Receiver (Denon). I previously used an old Harmony remote to control the whole system, but with the new components and the realization that I really only use the Apple TV as an input device, I wanted to simplify the remote setup.

The Apple TV and the Denon worked well together using HDMI CEC. This allows the Apple TV to turn the Denon AV Receiver on and off as needed, as well as to send volume up/down and mute signals over the HDMI cable.

However, the JVC Projectors do not support HDMI CEC, so I still needed the projector remote to turn it on and off. I could have re-programmed the Harmony remote, but they don't make them anymore, and the Apple TV remote is smaller and has all the functionality I need.

The JVC Projectors do support remote control over TCP/IP. I did some research and wrote a quick Go library to control the JVC Projector remotely. There are good libraries in other languages and some mobile apps (see the README in that repo) but I didn't find any in Go.

The next step was to listen to the HDMI CEC bus to trigger the correct On/Off commands at the right time. That leads to the inspiration for this project. I came across John Lian's post on HDMI-CEC. While he was addressing a different issue, it made me realize that I could build a 'bridge' between the HDMI-CEC bus and the JVC Projector.

I used the broad approach John outlined by setting up a Raspberry Pi (Model 2 B+ in my case) and connecting it to my Denon AV Receiver. The cec-client tool worked to see all the traffic on the bus, and it was fairly straightforward to identify the two different messages sent by the Apple TV I needed to listen to.

From there I wrote up a simple go app that would run the cec-client tool and parse its output. When it saw one of the two messages it used the Go library I wrote to turn the projector on or off.

I then set up the app to run as a service on the Raspberry Pi. So now to turn on (or off) the entire system I just need to turn the Apple TV on (or off).

Surviving the Great PSPS of 2025

Sat, 20 Dec 2025 01:08:00 +0000

Colorado is having a dry winter, and over the past few days we've had very high winds along the Front Range area, where I live. These conditions create a high risk for wildfires, as evidenced by the Marshal Fire in 2021. Xcel instituted a Public Safety Power Shutoff (PSPS) event twice in 3 days to reduce this risk.

The first event started about 10a on Wednesday and lasted until Noon on Thursday (14 hours). The second event started at 6a on Friday and lasted into Saturday (over 24 hours).

There are many ways to deal with an outage like this. Some of these include (from less to more advanced):

- Buy ice, candles. Low tech but it works

- Portable Batteries to power essentials

- Portable Generator to power essentials

- Whole Home Generator

- Bi-Directional EV

- Solar + Battery

While the ideal situation would be whole house solar with battery backup, for an uninterrupted supply of power, it is also an expensive solution that is only beginning to make economical sense if you can use it on a variable rate power plan to shift your daily usage. See Base Power in Texas.

A gas generator is a well tested and durable solution, either portable or a larger whole-house version. The downsides are that they require regular maintenance if not used regularly, they are noisy, and they burn gas.

While I do have (and love) my EV, it is not capable of bi-directional use. IE, I can't draw power from it other than to drive or through the cigarette adapter (generally limited to ~100W).

What I do have is a portable battery and solar setup I primarily use to augment the onboard solar and batteries of my camper. But the setup also works well in this situation.

My Setup (Prices current of 12/2025, including sales):

- EcoFlow Delta 2 Max ($850)

- EcoFlow 400W Solar Array ($599)

- Renology 400W Solar Array ($499)

- EcoFlow 800W Alternator Charger ($289)

The Delta 2 Max is a 2kWh portable battery with inverter. This means it can provide 2 kW of power for an hour (or 200 W for 10 hours). It can also charge from the solar panel arrays (up to 2) or the Alternator Charger (among other sources).

During the outage, I used extension cords to plug in our refrigerator, chest freezer, and networking gear (Internet, WIFI, etc), plus some phone/laptop chargers and lights.

The networking components draw a constant ~100W. The Refrigerator and Freezer each draw about 100-200W while the compressor is running, and the rest are generally less than 100W.

This means that the average draw was somewhere around 200-300W throughout the day.

While the sun is out (which is pretty brief as we approach the winer solstice) I used the solar arrays to keep the battery charged. But since they days were short, and there was quite a bit of cloud cover, the 800W of solar panels averaged only a couple hundred watts, generally about break-even. It is important to remember that even in peak conditions, the panels generally don't deliver their advertised power. I think about 350W is the best I've seen off either panel in the direct Colorado sunshine.

So for the rest of the day I utilized the 800W Alternator charger installed in our pickup truck (normally used to tow our camper). The Alternator Charger is an adapter that is hard wired to the battery terminals and outputs up to 800W to the EcoFlow battery. This means it is roughly capable of charging the battery (assuming no power draw) in about 2 1/2 hours.

This setup kept all the essentials running through the outage. The battery did drain overnight, but for the few hours the power was out the refrigerator and freezer stayed cold enough.

I only had to run the truck to charge the battery in the evening after the sun set, and then again right before bed to tip it off for overnight.

Overall this was pretty successful. We didn't have the constant noise from a gas generator, although we did have the truck noise in the evenings. It kept the food cold and the family entertained during the outage. With the truck standing in as a gas (diesel) generator to top up the battery, this solution can provide power indefinitely.

Since the primary usage of this setup is for camping, it is a nice bonus as a home backup solution. From a cost perspective, it is pretty expensive compared to a portable gas generator. A high end portable Honda that can output much more power would cost about 1k (less than half of this solution), but it would have to be running the entire time you want power.

The whole house solutions are much nicer, but for the limited use cases (this is the first outage of this size I can remember in 15 years here) they are very expensive for the value.

For shorter outages, the EcoFlow Delta 2 Max by itself, or with a single set of panels does compare well to a gas generator for a silent, more environmentally friendly approach. But for longer outages like this one it requires the gas backup (in this case the Alternator Charger).

One limitation we did discover is that the battery backup for our internet provider is only about 12 hours, but luckily for us they added a gas generator during the second outage to keep everything running.

Go Web Server using Lambda Function URLs

Sat, 21 May 2022 18:45:00 +0000

It has been possible to use Lambda Functions to host Go (Golang) Web Servers for years. I wrote about a project doing this back in 2016. More recently, the github.com/apex/gateway project provided a drop in replacement for net/http’s ListenAndServe function that supported AWS REST APIs, and later the AWS HTTP APIs.

Amazon recently released the ability to access a Lambda Function directly via URL, without needing to configure the REST APIs or HTTP APIs. This remove an extra layer of configuration, complexity, and potentially cost, for deployments.

I created a fork of the github.com/apex/gateway at github.com/ericdaugherty/gateway that supports this new approach. A trivial example of usage in the README is:

package main

import (
	"fmt"
	"log"
	"net/http"
	"os"

	"github.com/ericdaugherty/gateway"
)

func main() {
	http.HandleFunc("/", hello)
	log.Fatal(gateway.ListenAndServe(":3000", nil))
}

func hello(w http.ResponseWriter, r *http.Request) {
	// example retrieving values from the api gateway proxy request context.
	requestContext, ok := gateway.RequestContext(r.Context())
	if !ok || requestContext.Authorizer["sub"] == nil {
		fmt.Fprint(w, "Hello World from Go")
		return
	}

	userID := requestContext.Authorizer["sub"].(string)
	fmt.Fprintf(w, "Hello %s from Go", userID)
}

This is effective and addresses the issue, but can make local development a challenge. I often replace the main implementation above with:

func main() {

	// check and see if we are running within AWS.
	aws := len(os.Getenv("AWS_REGION")) > 0

	http.HandleFunc("/", hello)

	// run using apex gateway on Lambda, or just plain net/http locally
	if aws {
		gateway.ListenAndServe(":8080", nil)
	} else {
		http.ListenAndServe(":8080", nil)
	}
}

This uses the net/http implementation of ListenAndServe locally during development, and the gateway library when deployed via Lambda. No configuration is needed, as the AWS_REGION environment variable is automatically set by AWS when running as a Lambda Function.

One limitation of the Lambda Function URLs is that you can only access the Lambda Function URL via the aws domain (ex: https://<function id>.lambda-url.<aws region>.on.aws/). One easy solution to this is to use AWS CloudFront. For a simple use case, create a SSL Certificate in AWS for your custom domain, and then create a CloudFront distribution, using the SSL Certificate and the AWS Function URL as the default origin. If you use this approach, you should also make sure to set the HTTP Cache-Control Header on your cache-able responses to improve performance and reduce your Lambda invocations.

You can use a more complicated CloudFront approach if your project uses a lot of static assets. The static assets can be deployed via S3 and the CloudFront distribution can pull from S3 or Lambda depending on the request path, but for smaller or low traffic deployment, everything can be served from the Lambda function.

From here you can build your application using any traditional tooling that is supported by the Go http/net library.

Package Delivery Detector

Fri, 08 Feb 2019 16:37:00 +0000

The following is an outline of how and why I built a tool to detect when packages are delivered to my front porch. If you have enough of the right infrastructure in place, this will serve as a guide to get it setup yourself. All the source code is available, so if your setup is different, you can take and modify what I’ve done to work for you.

This solution is built using Go, AWS, Google Vision, and Docker.

Motivation

In November I attended Amazon's AWS re:Invent conference to catch up on the current state of the cloud. I came away from the conference inspired to leverage an area that I didn't have a ton of experience, Machine Learning. I attended several SageMaker sessions and came up with a project idea:

A tool that would use Machine Learning to detect when a new package was delivered to my home.

I already had a lot of key infrastructure in place, including a Ubiquity UniFi camera that was pointed at my front porch. I also had a Synology Diskstation with Docker that I used to run both my UniFi controller and UniFi NVR.

This project took a long time. I kicked off work in early December and I just recently got to the point where I’m happy with the results.

Image Capture

The key to this project is to build a Machine Learning model that can determine if there is a package at my front door. To build this model, I needed a lot of input data, so I started with a small app that would take a snapshot from my camera every few minutes and save it.

Luckily, UniFi cameras make it easy to grab a JPEG of the current frame. This is what my front door looks like right now:

I was able to grab this image with a simple HTTP GET request to the camera’s IP. Example: http://192.168.1.5/snap.jpeg

In order to enable this, I did have to turn on Anonymous Snapshots directly on the camera. Navigate to http://192.168.1.5/camera/config and click:

Since I would be running my image capture tool within my local network, I did not need to expose the camera to the Internet.

While this camera placement works well for my every-day use, it contains a lot of extra data that isn’t relevant to detecting a package, so I needed to crop each image down to just the area where I thought packages might be placed. Here is the result of my crop:

I now had everything in place to build out an app to start capturing images. I wrote the app in Go (golang) as it is perfect for this type of systems programming. The app simply polls the camera every 10 minutes, grabs the image, crops it (if desired), and stores it in an S3 bucket or on the local file system.

The source code is available on GitHub.

I wrapped the app in a Docker container and deployed it on my Synology. The Docker image is available on Docker Hub. Here is a sample Docker run command:

docker run --restart always \
 -d \
 -e TZ='America/Denver' \
 -v /volume1/imagefetcher:/img \
 --name imagefetcher \
 ericdaugherty/imagefetcher \
 -imageURL http://192.168.1.5/snap.jpeg \
 -dir /img \
 -sleepHour 22 \
 -wakeHour 7 \
 -rect 0,400,900,1080

This creates and runs a new Docker container that captures the images, crops them, and stores them locally.

Since packages are generally not delivered in the middle of the night, and the night images are much harder to see, I decided to only run the image fetcher (and eventually the package detector) from 7a to 10p. So I added parameters to the ImageFetcher tool to stop capturing images overnight.

The -e TZ=‘America/Denver’ parameter sets the timezone for the Docker container. This is important so that the timestamps are correct and the logic to sleep and wake work correctly.

The -v /volume1/imagefetcher:/img parameter maps the directory on the Synology to /img in the container, and then later the -dir /img specifies that the snapshots should be written to /img in the container, which will result in them being stored in /volume1/imagefetcher on the Synology.

If you would prefer to store the images on S3, you can add these parameters:

    -e AWS_ACCESS_KEY_ID='<Your Access Key ID' \
    -e AWS_SECRET_ACCESS_KEY='<Your Access Key Secret>' \

to the docker run command and this parameter:

    -s3Bucket <bucket name> \

to the imagefetcher command. You can then drop the -v /volume1/imagefetcher:/img and -dir /img, or keep them both and store the images twice!

Now you wait and capture data… I started with a month’s worth of images before I trained the first model, but I continue to capture images and plan on training a new model with the larger set.

Machine Learning Model

You should now have a S3 bucket or directory full of JPEG images. Now comes the fun part, you need to manually sort the images into two different labels. I chose the highly descriptive 'package' and 'nopackage' labels.

I use a MacBook, so I used finder to quickly preview the images and run through them until I saw a change of state. Then I moved all the images into either the 'package' or 'nopackage' directory. Repeat until you've processed all of the images.

This is pretty labor intensive, but it did go faster than I expected it.

You should end up with two folders, named 'package' and 'nopackage'.

I then spent quite a while trying to figure out how to train the model using SageMaker. I found this pretty frustrating as I'm not really fluent in Python, and it turns out the Machine Learning space is pretty large and not super-obvious to pick up. Luckily, I came across a post from Jud Valeski where he was building a similar tool to determine when the wind blew the covers off his patio furniture. He used Google Vision for his solution, so I took a look.

As it turns out, using Google Vision to build a simple model is drop dead simple. I signed up for Google Cloud account, created a project, and then created a new Google Vision model. To create the model, I simply had to zip up the 2 directories and upload it. In about 10 minutes, I had a functional model!

Google also provides you a HTTP Endpoint that you can use to evaluate images against your model. You simply post a JSON body including your image base64 encoded, and it gives you back what label matches, along with its confidence level.

Package Detector

With the trained model in place and a public endpoint I can hit, all that was left was to build the final tool.

The final source code is available on GitHub. The Docker image is also available on Docker Hub.

I lifted much of the logic from the imagedetector to grab and crop the JPEG image. I then wrote new code to base64 encode the image and upload it to Google Vision. Based on the response, if a package is detected, an email is sent out to notify me.

The current version supports email as the notification tool. I leveraged Amazon’s Simple Email Service (SES), but you can use any SMTP server you have appropriate access to.

This tool supports two triggers. The simple approach is to specify a simple interval, ex: -interval 5 and it will check every 5 minutes. However, I realized that the Unifi NVR is already doing motion detection, so if I could trigger based on that, it would only evaluate when there was a reason to do so. I came across a cool project by mzak on the Unifi Community Forums. Here is the GitHub Repo. Mzak realized that the NVR wrote a line to a log file (motion.log) every time motion was detected or ended. I leveraged his work to build a go library that would also monitor the log file. To use this, you must map the location of the motion.log file into the docker container. I do so with -v /volume1/docker/unifi-video/logs:/nvr and then point the packagedetector at this location with the -motionLog /nvr/motion.log parameter.

You can run the docker using the following command:

sudo docker run \
    --restart always \
    -d \
    -e TZ='America/Denver' \
    -v /volume1/packagedetector:/pd \
    -v /volume1/unifi-video/logs:/nvr \
    --name packagedetector \
    ericdaugherty/packagedetector:latest \
    -imageURL http://192.168.1.5/snap.jpeg \
    -rect 0,400,900,1080 \
    -motionLog /nvr/motion.log \
    -cameraID AABBCCDD1122 \
    -gAuthJSON /pd/google-json-auth-file.json \
    -gVisionURL https://automl.googleapis.com/v1beta1/projects/... \
    -sleepHour 22 \
    -wakeHour 7 \
    -emailFrom test@example.com \
    -emailTo test@example.com \
    -emailServer email-smtp.us-east-1.amazonaws.com \
    -emailUser <amazon ses id> \
    -emailPass "<amazon ses password>" \
    -emailOnStart true

I now receive an email every time a new package is delivered!

Looking ahead, I’m interested in building in support for SMS or even push notifications, although I would also need to build an iOS app for that. I also plan on continuing to refine the model with additional images until I’m confident it will be correct nearly all the time.

Simple HipChat AddOn in Go

Fri, 17 Mar 2017 00:12:00 +0000

We use HipChat at work to stay connected. It works well and has some fun plugins, including Karma. I’ll bet a few of you can guess what happens when you create a karma system in a company full of smart technical folks.

THEY GAME THE SYSTEM.

One of the more interesting hacks they discovered is to use the ‘find and replace’ functionality built into HipChat to secretly give (or more likely take) karma to/from another person. The proper usage of the Find/Replace functionality is something like:

> I can typo good.
> s/typo/type

The first line would be a typo that you made, and the second line allows you to ‘fix’ the typo. The key part here is that the second line modifies the first line and is not visible to any other users.

Who could let this fun discovery go unused? Not our team! Our chats were quickly filled with Karma Ninjas giving and taking karma from behind a thin veil of secrecy.

Luckily the Karma bot is open source. So I forked the source, made a fix and submitted a pull request right?

WRONG. Karma is written in JavaScript and writing JavaScript doesn’t make me happy. So I decided to create a Karma Ninja bot instead to ‘out’ the folks attempting to be Karma Ninjas. Since I’ve been exploring Go on AWS Lambda recently, I figured this would be a great excuse to write more Go!

Starting Points

There are a few options out there already that really helped accelerate the effort.

First, the eawsy folks created a great shim for Lambda that allows you to deploy Go easily and it runs FAST. Their solution is much faster from a cold start than the other NodeJS shims out there.

Second, Nicola Paolucci has a great post on the Atlassian Blog about building a HipChat addon in Go.

Finally, there is a HipChat Addon project by David Jonas on GitHub.

The eawsy Lambda shim is being actively developed and the team was very responsive to a few of the issues/questions I had, including one that is apparently a bug in Go 1.8.

The Atlassian blog post does a great job of walking through how to build an add-on. This was the template I ended up using for my addon. The only note I have here is that Nicola uses the roomId to store the authentication token, but that only works for single room installations. I used the OAuthId field instead which seems to work for both single room and global installations.

David’s project did not compile out of the box because of changes in the JWT Token upstream project. I thought about trying to fix is, but ultimately I wanted to understand how it all worked so I wrote mine without the template. I may go back and try to fix that project as an alternate implementation.

State

When I was envisioning building the plug-in, I assume I could build it statelessly. I assumed you could simply register a webhook with a regex and a callback URL that would return a message. But the webhook does not appear to let you return a message, you need to make a separate call into the HipChat API to post a message. Because of this, you need to maintain some state between calls.

EDIT: My first guess was correct, you can return a response to the webhook call and post a message. I ended up over-complicating it but the point was to learn more about AWS so it was still time well spent. Here is info on how to pass a response to the webhook.

I explored using both DynamoDB and S3 to maintain the needed state, which is really just an OAuth Token. They both worked fine but ultimately I chose to use S3 as it was the simpler and cheaper option for this use case.

Amazon does publish an AWS SDK in Go which made interacting with DynamoDB and S3 pretty easy. I do think the SDK is a bit ’low level’ and could probably be made a lot easier to use with some convenience functions, but I’m just happy they support Go so I shouldn’t complain.

The eawsy team does the necessary work to make the Lambda environment available from Go, meaning that you can simply use the Go SDK without any explicit authentication credentials or setup. By default, you simply inherit the IAM Role of the Lambda function. In this case, I simply needed to add permission to access DynamoDB and Se.

Code

The code itself is pretty straightforward. Like most go projects, I'm always impressed with how much you can get done in just a few lines of code across a handful of files. I published the project on GitHub: ericdaugherty/hipchat-karmacop.

AWS

This code does require some AWS setup. You need to define a Lambda function and build and upload the project using the Makefile (see the README for instructions).

You also need to setup an Amazon API Gateway entry to reference your AWS Lambda function. This will give you a public URL that your AddOn will reside at.

An S3 bucket is required to store the OAuth token used to post responses back to the HipChat API.

Finally, you need to add permission to read and write to S3 to the Lambda IAM Role configured for the Lambda Function.

That's It

This was a fun little project and shows a good use case for using Lambda to implement add-ons to cloud applications like HipChat.

How and Why I Became a 'Manager'

Thu, 16 Mar 2017 03:05:00 +0000

After my previous post about my approach to technical interviewing, I received some requests to write more about my career path. In this post, I’m will attempt to answer a question I get asked somewhat regularly: Why did I stop writing code and become a manager?

How did I choose Software?

Before we can dive into why I became a manager, we need to explore a bit more about who I was. Growing up, I loved Legos. I would spent hours building custom lego creations. As I got older, my family got a Commodore 64 and I spent hours playing cartridge games, watching Zaxxon fail to load from cassette tape, and typing in programs printed in computer magazines.

While I was in High School, I ran a dial-up BBS on a computer made from parts cobbled together from old computers and occasional purchases from Computer Shopper. I took all three classes in our computer lab at the High School: Typing, BASIC Programming, and Computer Drafting. Typing was the most important of those three. When I exhausted every class at the High School, I took a Turbo Pascal class at the local community college. If I wasn’t already convinced (I was), after that I knew I wanted to write software for a living.

I went to the University of Illinois to study Computer Science. Studying Computer Science at UIUC was the fulfillment of a dream for me, but I quickly made a small change. During my Freshman year I switched to Computer Engineering. This was precipitated by my experience with the Introduction to Algorithms class. It involved way too much math and theoretical thinking. I just wanted to learn was how computers worked. The Computer Engineering program offered a lot more low-level classes and less theoretical programming classes. My favorite class was our microprocessor design, where we started with basic logic gates and built up to a pipelined processor, including writing a program and running it on the processor. My second favorite class was x86 Assembly programming. I was happy with my choice to switch to Computer Engineering, and it put me in the position I dreamed of as a kid, I got to get paid to write software.

Did I like Software?

After graduating I started working for a consulting company. They did a great job of training new college graduates with a well-defined self-directed training course in C++. That was, practically speaking, the first and last time I got paid to write C++. The world was quickly transitioning to the web and Java. I was among the first members of our staff to learn Java for new projects, and being a primary Microsoft shop, a little J++ as well.

It was amazing. I was learning something new every day, and getting to build applications that real people were using every day. It was also when I first learned to dislike process and management.

This is probably best exemplified by a quick story. On the first project I had an opportunity to lead, I was asked to document the object model. According to our process, this involved opening up Microsoft Word, and defining each class and public method, including method signatures and JavaDoc formatted documentation in Microsoft Word. I thought it was a complete waste of time, I was frustrated that management didn’t understand software development, and I just wanted all the ‘useless’ people to get out of the way and let me build software.

I had another experience that furthered my distain for anyone other than developers. We were implementing Enterprise Application Integration (EAI) software written by Active Software for one of our clients. This involved moving data between several different enterprise systems. The pattern we used was to define a single message format for each data type that would contain all the data that could be consumed by every end systems. Active Software called this a ‘Canonical Message’. However, apparently the client didn’t understand what the world ‘canonical’ meant, and I spent the better part of an afternoon and the entire evening in a conference room with the entire project team attempting to come up with a new way to describe a canonical message without using the word canonical. It drove me CRAZY. I wanted everyone to get out of my way and let me go build something.

I swore I would never do anything but write code.

What Changed?

Fast forward a few years, and I had built up a solid skill-set, primarily in Enterprise Java but also a solid understanding in C#.Net. I learned how to build websites in Oracle Application Server 1.0, proprietary frameworks, Enterprise Java, Spring, and other variations.

I loved learning new frameworks. Each one brought solutions to problems I had struggled with, and as I learned, a new set of problems.

And ultimately, this was the primary factor in my evolution. After a while, a new framework brought a quick review and shrug instead of excitement and a deep examination.

My focus over this period was building enterprise applications running inside large companies. These are important systems and 'fun' to work on, but at the end of the day are largely reading data from a database, displaying it in HTML, capturing some changes, and writing data back to the database. It got old, especially when I became somewhat disillusioned with the evolution of the frameworks.

During this time, I also got to spend a lot more time working directly with clients. While this is often a frustrating experience, it allowed me to learn about a lot of different companies, industries, and business models. I came to respect the challenges that they each faced and the solutions that they had developed.

These factors caused me to pick my head up and look around at the world I lived in, and wonder what else I could be doing.

What Did I Know?

After spending close to a decade working primarily for consulting companies, I had broad but shallow knowledge of a lot of industries. I had worked for Fast Food, Manufacturing, Insurance, HR, Logistics, Banking, Financial Exchanges, and Retailers. I knew a little about a lot, but I didn't have deep knowledge of any. I realized that what I really understood was the consulting industry.

This worked out well since I currently worked for a consulting company. I looked around I started seeing other problems I could solve. Luckily, I was part of a fast-growing company with the trust of the ownership.

It started small. We had a small project and needed a part time PM. I stepped as the technical architect, but I also worked with the client to make sure we were delivering what they needed, and keeping them up to date on the project status and the challenges.

I also learned how the owner interviewed and I started helping out as the company was growing quickly and he was doing more interviews than he could handle alone.

I built trust and over time I took on more responsibility.

How Did I Learn?

I often get asked how I learned how to manage a company. The answer is pretty simple: just like I learned how to code. I read a lot and learned through trial-and-error. I also had great mentors.

This is an example conversation I often had with the owner of one of the companies:

Me: We should be doing X.

Him: Why?

Me: Because <a lot of reasons I thought made sense>.

Him: No.

Me: Why?

Him: Because <a lot of reasons I had not thought about>.

I would take what he said and reformulate my pitch based on this new information. It would often take several iterations before I either got a yes or I became convinced my idea wouldn't work for our company.

The great thing about the owner was that nearly every yes was followed by "go do this, I'm holding you accountable". This was a great way to grow my responsibility and take ownership of my ideas and see them through.

This conversation happened a lot, and over time I really understood what he cared about, and what his overall philosophy was. I agreed with much of his philosophy, but not all of it. We had many spirited discussions over the years, and I came away with a well developed philosophy of my own.

During this time, I expanded my reading habits beyond technology. I started reading business books, articles and anything and everything that taught me about how businesses worked. I learned about public companies by reading their 10K filings. I took a deeper look at our clients and tried to learn why they made decisions that I had previously thought were… strange.

And That Was That?

My transition to 'manager' wasn't over. My family decided to relocate to Colorado. Starting over in a new city with almost no professional network, I chose to go back to senior technical positions where I was actively writing code. I still have a passion for building software and, luckily enough, skills that were still valuable. But I eventually grew restless and started looking for a way to leverage my broader skills.

Then a very important event in my story happened: I took the family to Disney World. No, I didn't have an epiphany on my tenth ride on "It's A Small World", we only rode it 3 times. Instead, I met the CEO of Xcellent Creations on the flight home and found an opportunity to leverage the expertise I'd developed over the years to help grow a small mobile shop into an industry leader that we eventually sold to WPP.

Ultimately, I enjoy solving problems and building things. Whether those are Legos, software, or organizations, it doesn’t really matter. What matters is that it that the problems are challenging and that I’m working with great people.

My hope is that the organization that we’ve built today does for our employees what my past companies did for me. I want to help our team expand their skills, take on new challenges, grow as individuals, and view the world differently. And along the way, ship great apps.

Technical Interviewing and Hiring

Sun, 05 Mar 2017 02:35:00 +0000

There has been some discussion in the technical community recently about the use of algorithms and coding tests during the interview process. Here is a sample:

Hello, my name is David. I would fail to write bubble sort on a whiteboard. I look code up on the internet all the time. I don't do riddles.
— DHH (@dhh) February 21, 2017

Hi, I'm Py. Used to think I didn't need to learn CS. I was lazy. I practiced for interviews, and it made me a better Software Engineer. https://t.co/yD5NzcmTwF
— Py ⚔ (@Piwai) February 23, 2017

I have my own thoughts I would like to share, but this isn't really a topic for 140 characters.

Why should you care what I think?

I've spent a lot of time interviewing and hiring developers across several organizations. For a while I was doing interviews every day. In fact, I remember telling my recruiter that he couldn't schedule more than 2 interviews in a day because by the third interview I found I was no longer effective. I estimate that I've interviewed over 300 candidates, and been the primary decision maker on over half of those. I have been a key member of the interviewing and/or hiring team in two custom software services companies that have grown from 30 or fewer people to over 115 during my tenure. I've done this a lot, and I was there to see my successes and my failures.

I spent over a decade primarily as a software developer. I’ve written production code in LabView, C++, J++, Java, VB, Perl, C#/.Net, JavaScript, Flex, Scala, Objective-C, and probably more. I’ve probably written more Java than the rest combined, but I was always learning something new and during the time that I was doing these interviews, I knew what I was talking about. I would like to think I still very technically competent, although many of my current employees enjoy proving me wrong regularly.

I leaned this approach from a great mentor early on, and adopted and extended it over the years. We all stand on the shoulders of giants.

Is this the one true way?

Before I describe my approach, I want to focus on a key point lost among the 140 character conversations. Your interview process should identify candidates that will work in YOUR organization. Your company probably isn't just like David Heinemeier Hansson's, or anyone else you read on twitter. It probably isn't just like the companies I've worked for either, so if you blindly copy what was successful for me, you will probably still fail.

I’ve spent most of my career working for services companies building great software, from enterprise back-end systems in Java and .Net to amazing mobile applications in Objective-C, Swift, Java, and Kotlin. Because these companies are services companies, I expect my employees to be able to interact directly with out clients. The people I hire must be capable of more than just writing great code, they must solve our clients problems, by understanding what they really need, communicating effectively with technical and non-technical people alike, and delivering a great technical solutions.

I also expect my employees to be able to learn a new technology quickly. The landscape is always changing, and when you are building software for other companies, you do not have the luxury to define what technologies are and are not acceptable.

Therefore, I focus on hiring great problem solvers. If you are not a good problem solver, you will not work on my teams, no matter how amazing you are at language/framework/platform XYZ.

So what is the interview like?

Most of these interviews last about an hour. The four sections are...

Cool Stuff - ~15 Minutes

I start all the interviews by asking the candidate what projects they think are cool or projects they are proud of. These can be work projects, open-source projects, school projects, or just tinkering around and learning projects. This engages the candidate and allows them to talk about topics they are comfortable with.

This tells me several things. First, it tells me whether they communicate effectively. I actually prefer when they have a project in an area that I am not knowledgeable. Selfishly, it lets me learn about something new, but the primary reason is that it show me whether they can explain a technical concept to me that they understand well. If it is in an area that I know well, it lets me probe to see how well they really understand the topic.

It also helps me level-set where the candidate is. Ignoring their resume, the projects and accomplishments they are proud of tell a very clear story about their skill level and world view.

Coding Problems - ~20 Minutes

What!?! Yes, I have two basic coding/problem solving problems that I make each candidate work through, on paper, in front of me.

Problem 1:

This is essentially a recursive coding problem. You can solve it in any OO programing language with a basic knowledge of the core syntax. It does not require any API/Framework specific knowledge. The right answer is about 4 lines of code.

I have given this problem to everyone from college students looking for their first job to senior architects. They should all be able to solve it. I do adjust my expectations based on the level indicated by their resume and 'Cool Stuff' answers.

Achieving a Passing mark on this doesn't necessarily require a perfect answer right away. I'm happy to ask questions, and give small hints to the candidates if they get stuck. This is actually one of the most valuable parts of the process because it allows me to see how well they listen, and how they think through a problem. But if you can't write (simple) code down on paper with a reasonable level of accuracy, and you can't write a basic recursive method with a few hints, you are probably not going to cut it.

Problem 2:

This is where I date myself somewhat. Problem #2 is ideally writing a SQL statement, but is really a boolean logic problem. It does not require anything other than very basic SQL syntax. No Joins, or anything even slightly fancy. The right answer would fit in a single tweet.

Again, I have given this problem to everyone from college students looking for their first job to senior architects. They should all be able to solve it. I have run into college students that didn't know SQL, and in those cases I was able to adapt it to be a boolean logic problem that they could solve in general set notation.

Again, success here is showing me how you think through and solve problems. You don't need to write the correct answer down flawlessly the first time, but you have to show me that you can think through a problem, listen to feedback/hints if necessary and incorporate them into your thinking.

Alternate Problem:

Depending on time and level, another question I've asked A LOT, mostly to Java and .Net candidates, is how garbage collection works in the JVM (or on .Net).

Occasionally I'll get a candidate that actually knows the answer, and while impressive, this is actually somewhat disappointing. The point of this question is to have them show me their problem solving skills applied to a real technology that they depend on every day, but probably don't think about.

This questions shows me how well a candidate can listen, how well do they think on their feet, and how well do they actually understand computer science concepts.

Again, the 'right answer' isn't necessarily the point. Having a great conversation with me where in the end they really grasp the concept and feel like they are a better developer makes both me and the candidate feel good about the interview.

Side Note: I was working with a startup (not my full time job) and helping them make their first full time developer hire. I used these problems and rejected a candidate. The CTO, who had not actively developed in several years, challenged me about the questions, so I gave him the interview. He passed both in less than 10 minutes, and realized that he didn't want anyone on his team that couldn't solve these problems. The next person we interviewed passed, was hired, and did a great job for them for several years.

Resume Due Diligence ~ 15 Minutes

Once the problems are solved, I will use the next section to tackle any areas of interest that I think are appropriate. I will often read through the resume and ask questions about specific projects/accomplishments to determine how accurate the descriptions are and what role the candidate actually had on those projects.

If they profess deep knowledge in a certain language/framework/platform, I may go deep in this area to see how much of an expert they really are. I love learning something new from candidates, and they usually enjoy teaching the interviewer something new as well!

A big take-away from this section is: how honest are they about their resume? Were they exaggerating, or underselling themselves?

I can also use this time to follow up on areas the candidate showed a particular interest in to see how deep their knowledge is.

Candidate Questions ~ 10 Minutes

The final section is an opportunity for the candidate to ask me questions, about the role, culture, expectations, etc. While this is a key part in making sure the candidate is sold on working for me, their questions are also a window into their thought process and outlook, and can be informative in making a hire/no-hire decision.

Ultimately thought, this section is about closing the candidate. Regardless of whether you will hire the candidate, you want them to be sold on your company, and you want them to feel good about the experience. Even if you pass on them, you want them to leave the interview with a positive opinion of you and your company. It is a small world.

Why do I do is this way?

I've covered a lot of the why along the way, but it important to reiterate and expand on my motivations and goals.

First, I want to reiterate that I target hiring great technical consultants. We build software solutions for other companies, and the skills we look for reflect that. This is probably not a great approach for other types of companies.

I firmly believe that in order to be a great software consultant, you have to be a great problem solver. To me, this includes listening and understanding the problem (solving the right problem), deep enough technical expertise to identify a good solution (there is rarely one RIGHT solution), the ability to communicate what the solution is, what the trade-offs are (there are always trade-offs) and how it addresses the actual problem, and the ability to deliver the solution.

In the companies that I worked for, we certainly didn't expect an Associate Developer to interact directly with the client and execute all of these steps, but this is still the ultimate process and everyone should be able to participate at the level of their experience.

I also don't believe in team interviewing for smaller services companies. A consultant working for one of these companies will need to be successful across different clients and different teams. I believe in the accountability of a single decision maker, and if the process is consistent, then the team members know the people getting hired went through the same process they did. Ultimately, if the team trusts the hiring manager, they will trust the candidate that they hire. However, this doesn't scale and as a company grows, the process needs to evolve.

Again, this probably doesn't work for other types of companies, and team interviews make sense in a lot of cases.

Finally, I do it this way because it works. Yes, I made a few bad hires over the years. In each case, I went back to look at the interview notes to see what I missed and how I could do better next time. In some cases I was being too optimistic because I was desperate to fill a need. In some cases the candidate simply snowed me. In some cases, there is an issue that I can't reasonably expect to uncover in an interview.

Final Notes

The lifeblood of the interview/hiring process is the great work that your recruiters do. I firmly believe in having in house recruiters and I've been blessed to work with some great ones. You know who you are, thank you.

I have no idea how many false negatives I've had. I would argue it is unknowable. But the growth of both companies would suggest that I didn't turn away too many qualified candidates.

These opinions are my own, and do not reflect those of my employer. I am no longer in a role where I make any hiring decisions on technical candidates, so don't expect that reading this post will give you an inside edge. ;)

This post is too long. Unfortunately, I'm not a good enough writer to write a shorter post. I'm sorry.

GoLang Alexa SDK

Sat, 04 Mar 2017 03:28:00 +0000

I continue to be interested in Alexa, Amazon AWS Lambda, and Go (golang), and I’ve found a new way to deploy Alexa apps in Go on Lambda.

While Go is still not an officially supported language on Amazon Lambda, there are several ways to make it work:

Lambda_proc - Node.js wrapper for your go binary
GopherJS - Cross-Compile your Go code to NodeJS
eawsy Lamba Go Shim - Python shim for your go binary

In my previous project where I built a screen scraper in Go and deployed it to Lambda, I utilized Lambda_proc. This does work pretty well an is a solid solution.

I found GopherJS to be an interesting project, but a pretty indirect way to get Go onto Lambda. Lambda can run Go Linux binaries, so converting your Go to JavaScript seems like the wrong approach.

The eawsy team released their new tool earlier this year and it seems to be the cleanest approach. The overhead between the Python shim and your Go code is clean and fast. They utilize a Docker container to build the necessary bridges from Python to Go, resulting in very fast execution. You can write log messages to the Lambda console using log.Printf. And it is FAST. The HelloWorld skill runs in sub-millisecond times!

To build Alexa skills in Go on Lambda, we still need an SDK. Amazon publishes SDKs for Java and JavaScript but not for Go. So I ported the Java SDK into Go as ericdaugherty/alexa-skills-kit-golang While this does not (yet) have the full depth of the Amazon SDK, it does enable you to build simple Alexa skills using Go and deploy them on Lambda.

Take a look at the alexa-skills-kit-golang project for usage and samples, and give the eawsy Lamba Go Shim a try for your next Go project on Amazon AWS Lambda.

- Updated 3/4/2017 - updated run time based on newer stable eawsy shim speeds.

Lamda, Go, and GotSport via API Gateway

Sat, 12 Mar 2016 00:10:00 +0000

While I’ve been primarily living in the mobile world recently, I’ve been intrigued by a the developments in a few other areas of technology.

Go, or golang, has been increasingly becoming my preferred language for side projects. I really like the concise nature of the language, the ability to deploy on multiple platforms, and the short tool chain. It ‘just works’, and is fun to program in.

AWS continues to add interesting services and features. I recently moved my website from GoDaddy to host on S3. This really started my thinking about living in a ‘serverless world’. While practically speaking hosting on S3 isn’t really all that different than virtual hosting at GoDaddy, it is really just scratching the surface. You can now build pretty interesting applications without running a server (virtual or otherwise).

I begin to think about how you could build a full application using the AWS stack without an EC2 instance. Of course, a ton of thought has already been put into this. The Serverless tool allows you to easily configure Amazon to use the API Gateway with Lambda to deploy functional APIs. There is also a website dedicated to living serverless.

I’ve also been working on a few Amazon Alexa applications for the Echo, which also uses Lambda as the preferred deployment program.

So I thought it was time to build something that actually works.

My son plays soccer and the Colorado Soccer Association uses the event.gotsport.com website to post schedules and results. So I built a screen scraper in Go to parse his schedule into JSON so I could use it in my Amazon Alexa application. (The scraper is here: https://github.com/ericdaugherty/gotsport-scraper) But I hard-coded the resulting JSON into that application.

I figured I could build a general API that could be used by anyone to convert the schedules into JSON. And I could easily deploy it on Lambda.

In order to get Go running on Lambda, you need to ‘work around’ the fact that it isn’t officially supported. The lambda_proc library (https://github.com/jasonmoo/lambda_proc) does just that. It uses a node.js wrapper that invokes your Go application within the Lambda runtime. The repository has a good example that should you how to write and deploy a go app on Lambda.

From there, I just needed a simple Go app to take the input JSON, run the gotsport-scraper I wrote, and return the resulting JSON.

The final step was exposing the Lambda function as an HTTP API. This is where the API Gateway comes in. It allows you to specify an endpoint and method to trigger the Lambda function. The basics are pretty straightforward. You define a resource (/gotsport) and a method (GET), and map it to your Lambda function. However, the tricky part is the mapping of the HTTP Request to the Lambda function, and the result of the Lambda function to the HTTP Response.

Here is the full lifecycle:

I decided to use Query String parameters to pass data to the function, so you could just cut/paste from the URL you wanted converted. You can define the query strings in the Method Request section, but this just seems to allow you to use them when testing and isn’t required. I did have to map the query parameters into the Lambda, so I created an application/json mapping (since the Lambda function consumes JSON). The mapping function is:

{
    "eventId" : "$input.params('EventID')",
    "groupId" : "$input.params('GroupID')",
    "gender"  : "$input.params('Gender')",
    "age"     : "$input.params('Age')"
}

This maps the Query String Parameters using their names (again, as used on gotsport.com so you can cut and paste) into JSON values that match those used by me gotsport-scraper tool. This is then passed to the Lambda function.

The Lambda function runs, fetching the requested URL, scraping it, and returning a JSON value. However, the lambda_proc function returns both an error value and a data value containing the results of the Lambda function. I wanted to map the output to just contain the JSON representing the schedule. So in the Integration Response step in the lifecycle, I used the application/json mapping function:

#set($inputRoot = $input.path('$'))
$input.json('$.data')

This just extracts the data element from the JSON returned from the Lambda function and passes it back as the HTTP Response Body.

The proper approach in the Integration Response step is to use a RegEx to determine if an error occurred or not, and return the proper HTTP response code and appropriate body. For now I’m assuming a 200 response with valid data.

That’s it! I now have an HTML->JSON screen scraper for the GotSport website deployed as an API.

Want to see how this all works. Here are the resources:

lambda_proc - Run GoLang apps on Lambda
gotsport-scraper - Screen Scrape the event.gotsport.com site
gotsport-lambda - Lamba function to execute gotsport-scraper
Amazon API Gateway - General API Gateway documentation
Amazon API Gateway Mapping - Documentation about writing mapping files.

Want to test it out? Grab a specific schedule from the CSA Youth Advanced League 2016 site. Then cut/paste the query string parameters onto my API URL: https://j4p9lh1dlb.execute-api.us-east-1.amazonaws.com/prod/gotsport For example, the U-11 Boys Super League would be: https://j4p9lh1dlb.execute-api.us-east-1.amazonaws.com/prod/gotsport?EventID=46461&GroupID=511424&Gender=Boys&Age=11

Unit Testing with throws in Swift 2.0

Mon, 23 Nov 2015 00:26:00 +0000

I’ve been working very slowly on a Swift version of Playlist Export, and today I finally got around to updating the project to Swift 2.0. Luckily I wrote test cases for much of the logic to manage the export process, so I had some level of confidence that I would know if I broke anything.

However, after I got the project to compile, only one of the test cases ran. No errors or other indication why all the other cases were ignored.

I did finally figure out that if you your test case has a throws clause, it will be IGNORED.

So:

testPlaylistNameExtension() throws {
    ...
}

will silently be ignored, which for a test case is a pretty bad scenario. But if you handle the error in the function and change it to:

testPlaylistNameExtension() {
    ...
}

then everything is just fine. So if you have test in Swift 2.0 that are ignored or not executed, check to see if you have a throws in the function declaration.

Home Theater

Sat, 17 Oct 2015 20:18:00 +0000

I recently got to fulfill a longtime dream of building a ‘home theater’. Luckily, the basement was already finished with a room that was large enough to house a home theater, so as home theater projects go, it was pretty straight forward. This is a write up of the project, which I completed in May of this year, so I’ve had almost 6 months with it completed.

The room was previously setup as a TV room, with a 60" Rear Projection DLP TV (Mitsubishi WD-60738), a very large entertainment center I purchased for a much larger room in a previous house, and a sectional couch.

The 60" TV and too-large entertainment center:

This setup also consisted of:

Onkyo TX-SR605

3 Phase Tech PC-3 Speakers (Fronts)

2 Phase Tech PC-60 Speakers (Rears)

Phase Tech TODO Subwoofer

Sony Blu-Ray Player

DirecTV HR20-700 DVR

I also had an IR repeater setup, with most of the components already located in the utility room next door. The system was based on the Niles IR Repeater with the receiver and emitters cobbled together over many years.

The room has three walls, with the back open to a larger room, and no windows on any of the three walls. The room was 11.5’ wide x 17’ deep, which wasn’t quite as wide as I would have liked, but gave me plenty of length, especially since I could spill over into the larger room behind it.

The existing room and equipment provided a solid foundation for the new home theater. The Onkyo receiver and HR-20 were both used in the new setup. I struggled about whether to keep the Phase Tech speakers or replace them, but ended up replacing them. They had been ‘well used’ over a ~15 year lifespan, and the speaker cones were in need of repair, some of the dome tweeters were smashed, and there was some loose material in the speakers that you could hear when you lifted them. The rears were also pretty large to be wall mounted, which made it awkward to walk past.

While researching the room, I leaned heavily on two resources:

1. The Wirecutter

2. AVS Forum

I really appreciated the Wirecutter’s approach of picking the best item in a given category. It really simplifies the decision making process, but also does give you a few options in addition to their pick so you can really understand the trade-offs that exist. This site is how I picked the screen, projector, and heavily influenced the selection of the speakers.

For the projector, I pretty much took the Wirecutter’s recommendation, and verified the selection by reading reviews on AVS Forum. I selected the Sony VPL-HW40ES. Overall, I have been very happy with the projector. The picture quality is great, it is relatively quiet, and has worked flawlessly so far. I did briefly consider a 4k projector, as the HW40ES is only 1080p, but my logic was that the cost difference for early stage 4k projectors wasn’t worth it, and by the time 4k content becomes readily available there will be better projectors out for much less money.

I mounted the projector to the ceiling with a set of Chief components, the CMA-101, CMS-003, and RPA-020. This is very solid and pretty easy to get setup and aligned.

There are a lot of options for screens, but since I was in a basement and had full control over the light, I didn’t need a high gain screen. I could also use a fixed screen since it would be permanently mounted to the wall. Again, I want with the Wirecutter’s recommendation of the Silver Ticket 100" (diagonal) screen. It takes a bit of effort to put it together, but it was straightforward and I was very pleased with the finished product.

Once I decided to replace the speakers, I really struggled with how to select the best options. Many quality speakers are now sold directly to consumers, allowing you to skip the AV Store listening rooms. I spent a lot of time listening to speakers 15 years ago when I purchased the Phase Tech speakers originally, and frankly I didn’t want to go through that again. I turned to the Wirecutter and AVS Forum again for advice. In the end, I started with the Wirecutter recommendation for surround systems, although I found the runner up at the time, the NHT Absolute 5.1 system more interesting. However, I had an existing sub that was more than adequate for the room, so I ended up with the NHT Classic Three bookshelf speakers as the fronts, the Classic ThreeC as the center, and their thin Absolute Wall Speakers as rears. I’ve been very happy with them so far as well.

While I had an existing Sony Blu-Ray player, I decided to upgrade it because I wanted to move it to another room to replace an existing DVD player. For this, I ended up going with a popular selection from the AVS Forum, the OPPO BPD 103D. I really like this player, but I’m not totally convinced on the Darby processing. I have the Darby signal processing applied to both the OPPO sourced video as well as running the DirecTV video through it. I can certainly see some differences in the side-by-side option it has, especially when you crank the processing up high. I have mine set at 35 I believe, and mostly take it on faith that it is better. That said, as the owner of a phenomenal early DVD player, the DVP-7000, I’ve been mostly disappointed in every DVD or Blu-Ray player I’ve purchases since then. The OPPO is the closest thing to the DVP-7000 that I’ve owned since, and that his high praise.

To round out the electronics portion of the upgrade, I bought a Harmony 650 remote. I’ve used Harmony remotes for as long as I can remember and I’ve been happy with all of them. I was somewhat leery of moving from a Harmony One to the 650 based on some feedback I had read, but I was very please with the 650 and it does everything I need.

For the furniture, the room wasn’t quite wide enough to put 4 seats and leave enough room for an aisle, so I ended up with two rows of 3 HT Design Devonshire chairs. Since I could only fit 6 chairs, I added a bar behind the chairs with 4 stools, increasing our capacity to 10 people and providing a space to eat and socialize when we had people over to watch games, etc. I’m generally happy with the chairs. They are very comfortable and feel well-built. I think the back-lit buttons are a bit too bright, and could generally do without the lights on the chairs, as guests have a tendency to turn them on without realizing it. I need to just disconnect them, but have not gotten that far.

The riser is a bit time-consuming to build, and the instructions are horrible. There were some YouTube videos, but they seemed to use slightly different hardware and were of minimal use. We did re-carpet the basement towards the end of the project, so we were able to get the riser carpeted to match the rest of the room easily. The riser is really just tall enough, although anything taller and you’d be banging your head on the ceiling when you stood up, so it works well.

I purchased all this from the following sources, and had good experiences with all:

Craig at AV Science, Inc. set me up with the projector and the Chief mounts.

Alan at HT Market set me up with the chairs, riser, and bar.

I bought the speakers directly from NHT.

The rest was purchased on Amazon or elsewhere.

Here is the finished product:

Site Migration

Wed, 05 Aug 2015 23:34:00 +0000

After hosting this site on GoDaddy for many years, I’ve decided to migrate it to Amazon via S3. Amazon has some great features for hosting static websites, although I’ve gone ‘bare bones’ to start. I’m just hosting using an S3 bucket. I’m using the wwwizer Naked Redirect service to redirect ericdaugherty.com to www.ericdaugherty.com, and then hosting the site out of a S3 bucket.

Amazon has a DNS server (Route 53) and CDN (CloudFront) that are easy and inexpensive to use, but I don't think I need them yet. For now, I'm still using GoDaddy's DNS Server and the wwwizer 'hack' instead of Route 53.

The previous site utilized somewhat of a 'poor man's template engine'. I had a html file for each page on the site, but had Apache evaluate them as PHP files and I used PHP Includes to build up the page using common components.

Moving to a fully static website meant I needed a real template engine. I selected Jekyll and migrated the site over. It was a pretty straight forward migration and ended up reducing the size of each file as I could use a true template instead of just having common components.

I then use the AWS console tool to upload the generated website files to S3 for an easy deployment, also allowing me to finally retire FileZilla from my tool chain.

Amazon has some pretty good guides to doing this, but I also used two good blog posts: Amazon S3 on Domain Root, without Route 53 and Static website on S3, CloudFront and Route 53, the right way!

The blog portion of the site is still hosted at Blogger, which has and continues to work well.

This also forced me to make a few updates to the site, fixing some broken links and removing some no-longer-relevant sections.

Plus it gave me an excuse to finally post on the blog.

USA Pro Cycling Challenge 2014

Tue, 26 Aug 2014 03:12:00 +0000

The USA Pro Challenge rolled through Golden this weekend, and I headed to town to try to get some shots.

See all the USA Pro Challenge 2014 pictures on Smugmug.

The race brought them through Golden and then up Lookout Mountain. They managed this climb in less than half the time of my best effort. They came back and did a loop through downtown Golden before heading down to Denver for the finish.

I positioned myself at the corner of Washington and 10th to catch them coming through downtown Golden, with the ‘Welcome to Golden’ sign in the background.

Here is the overall winner rolling through Golden:

This lone rider nearly got clipped by one of the support cars

Fireworks in Estes Park

Sat, 05 Jul 2014 16:44:00 +0000

I spent the 4th of July in Estes Park this year, and enjoyed a great fireworks show in front of the Rocky Mountains.

See the rest of the pictures here.

Alluvial Fan in Rocky Mountain National Park

Sun, 01 Dec 2013 00:24:00 +0000

I got to visit Estes Park and Rocky Mountain National Park this weekend, which gave me a chance to see some of the flood damage from this fall. Nothing was quite as impressive as the amount of material deposited at the base of the Alluvial Fan in RMNP. The river used to run down the mountain and under the bridge. The bridge survived, but as you can see, it no longer crosses the river. The river used to flow about 15 feet under this bridge. Now there is rock and sand above the level of the bridge…

Instead the river has redirected a bit farther west and took out the road. The amount of material that was brought down was impressive. These signs both used to be normal height…

And this sign was taken out by the flow of water, sand, and rocks.

Just about everything in this picture was not here previously. All these rocks and sand was brought down during the flood.

Hiking with a DSLR - Part 3... and other accessories

Wed, 30 Oct 2013 22:28:00 +0000

Every year or so I post about my camera setup, and the gear I use to carry it while hiking, etc. Here is this year’s update…

You can go back and read last year’s post, or my 2010 post to see how I’ve changed over time.

Since last year, I’ve upgraded from the Nikon D300 to the D600. Since it is now a full frame, I also switched my primary lens to the D600 24-85mm f/3.5-4.5 kit lens. Both the D600 body and the lens are smaller than D300/17-55 f2.8 I carried before, although I did give up some speed on my walk around lens.

Camera Mount

The Cotton Universal Adapter is constantly attached to my camera. With its Arca-Swiss compatibility, it can easily be mounted on my Tri-Pod and Mono-Pod, as well as carried using the Cotton system. I also have the Cotton Hand Strap attached as my primary strap. I don't like or use a neck strap.

Hiking/Walking

I continue to find the Cotton Strap Shot to be the ideal carrier solution while hiking. Mine never leaves my REI daypack, which I carry on just about every day hike. It holds the camera securely and out of the way while hiking, but I can still have it up and ready to shoot in seconds. The tether is a nice bit of extra security as I don't keep a neck strap on my camera.

While I own the Cotton Carrier Vest and Side Holster, they don’t see a ton of activity. The vest is great if you want a really stable mount for your DSLR, but I find that for most activities where it would make sense (biking, skiing), I carry my GoPro instead. I do occasionally use the side holster, and it is a good companion to a waist pack, where you have a heavier belt meant to support weight of it. I used it once this year on a shorter hike where I just wore a waist pack and it worked well.

For more casual walks, I use my BlackRapid strap. It screws right into the Cotton Universal Adapter so it is quick to throw on the camera and works great for casual walks where you are taking a lot of pictures. It isn’t stable enough for more intense walks or hiking, but if you are walking around town it is a great option. I’ve had my RS-1 since 2008, and it continues to perform well. Well worth the $44 dollars I spent, although it looks to be a bit more expensive now.

Tri/Mono Pods

I have a Gitzo Basalt Tripod (GT2932) that continues to work very well, and a Sirui P-326 Monopod that I like as well. The Sirui's padding is starting to split a little after only 6 months, but it is fine otherwise. Both with Arca-Swiss compatible mounts.

GoPro

In addition to the DSLR, I added a GoPro Hero3 to the mix this year as well. I primarily use it while skiing, although I have used it while swimming and snorkeling in the ocean this year as well. For carrying the GoPro, I use three main options:

The GoPro Chesty works great if you are primarily shooting video of yourself skiing. It provides a very stable platform (your torso), and makes the camera accessible to you, allowing you to control it directly instead of using a WiFi control (iPhone or Remote).

The Helmet Mount works well if you are taking video of someone else skiing. It allows you to steadily track them while you move back and forth across the mountain. It is more difficult to control, and pairs well with a WiFi control, although this really drains the battery, especially in cold conditions.

I like both of the above and end up switching back and forth during the season. Either is a solid option.

This summer I picked up the Wrist Housing, primarily for my trip to Hawaii for use while swimming/snorkeling. I found it worked well. It was not overly obtrusive while swimming, and easy to control, even underwater. I also used it on a kayak trip, and again, it didn’t bother me while paddling and kept the GoPro available for nearly every opportunity.

Bags

My main camera bag is the Lowepro SlingShot 200. I've used this bag for about 4 years now, and it is my primary carry bag. It fits the D600 with the 17-55 mounted, as well as my 80-200 and a couple prime lenses. This is really my main carry solution, as it works well to carry the DSLR when you want to have your other lenses available as well. You can quickly rotate the back from your back to your chest and pull out the camera. It also provides a steady platform for changing lenses on the move. It looks like the Slingshot 202 is the current iteration of this bag.

I also added a travel bag, the Fastpack 350. This allows me to carry my camera, all the lenses, as well as my laptop and assorted cables. This is my carry on bag when flying. Although I often throw my SlingShot in my checked luggage if I’m traveling for more than a weekend, so I can use it once I’ve arrived.

Summary

Overall, I'm very pleased with the solutions I have in place. I'm not looking to replace any of the solutions I have now, although I'm sure as new products come out I will be tempted.

Note: I purchased almost everything myself, including the Cotton Carrier Vest, SideHolster and various adapters, but Cotton did provide me with the StrapShot and Universal Adapter plate for free.

Kauai Hawaii

Tue, 15 Oct 2013 01:23:00 +0000

I spent last week relaxing on beautiful Kauai Hawaii. Here are some of the pictures I took during the visit.

Coyote Pups

Mon, 10 Jun 2013 23:08:00 +0000

There are a new litter of Coyote pups in Rocky Mountain National Park (RMNP) this year near the Beaver Meadows visitor center. I was able to capture a few good shots of the pups playing around near their den.

See all the pictures here, a few selected shots below…