Mat Schaffer's blog

Monitoring my home internet with Elastic

2021-10-04T00:00:00+00:00

Since the start of COVID19, my home internet has gotten noticeably slow between the hours of 8p and midnight (JST, local).

I suspect this is a widespread issue as more people are staying home and doing things that exercise both local and global internet connections.

My ISP seems to do a decent job keeping things like video streaming prioritized, but work can be a big pain. Operations like apt update/install on a local VMs, npm install, browsing company websites can get very slow. It’s even worse when I’m on a full-tunnel VPN as I suspect in this case my ISP can’t make any sort of traffic priority decisions.

For the last year, I mostly ignored it. With so much of the world suffering and dying, it’s difficult to complain about slow internet.

But it’s gone on so long now I decided to at least get scientific about it.

The approach

I figured if I could have something like Ookla Speedtest running continually and storing data, I could demonstrate and quantify the issue.

But what to use?

Internet Speed Logger

Having recently helped out Elastic Uptime I first reached out there.

It was notably outside their intended scope, but the project’s PM mentioned he’d done similar home network testing with Brennen Smith’s Internet Speed Logger

This got me some quick results:

But it left something to be desired. It was hard to see what time the dips were happening and I didn’t see any options to change aggregations or do other processing. I’d probably have to hack on the code directly to draw useful conclusions.

Additionally this was a mongodb+node setup on docker compose. Easy to do on my MacBook, but a little trickier to run from my Raspberry Pi 4 which was the handiest stable computer on my network.

Using the Elastic Stack

I mentioned my testing in passing to one of my coworkers, Toby Brain, who said he did something similar with the Ookla CLI shipping data to Elasticsearch.

This sounded great for the following reasons:

I could host Elasticsearch & Kibana on cloud.elastic.co and not worry about data storage availability
Filebeat and the Ookla CLI should be light enough to run on my Raspberry Pi

Setting up the cluster

This was easy! Just go to cloud.elastic.co, sign up and make a cluster.

If you don’t happen to work at Elastic, you’ll get at 14 day free trial. If you want more, you could start a paying plan, or consider getting a job at Elastic ;). Or of course you could also host your own elasticsearch and kibana on a spare machine with enough resources (but probably not a Raspberry Pi). The data set is quite small. Only about 600kb for 3 days so far.

Setting up the Ookla CLI

Installation here is easy. Just grab a copy from the speedtest cli download page for your process (arm in my case) and untar it. Move the binary somewhere handy (like /usr/local/bin).

One small “gotcha” is that each user has to run it once with no args to accept the EULA which will write into $HOME/.config/ookla). No big deal for my setup, but if you have users without home directories or something, watch out for it.

To run the speed test and get json output, you’ll need a server ID. You can get one like this:

$ speedtest -L
Closest servers:

    ID  Name                           Location             Country
==============================================================================
ド田舎ネットワーク！By mino7r86. Kawagoe              Japan
Allied Telesis Capital Corporation Fussa-shi            Japan
denpa893                       Tokyo                Japan
NEVERLOSS LLC.                 Tokyo                Japan
LiyingNetwork                  Tokyo                Japan
Netprotect                     Tokyo                Japan
k-kohei.jp                     Tokyo                Japan
SERVG.NET MG-Network           Tokyo                Japan
NEROCLOUD INC.                 Tokyo                Japan
Misaka Network, Inc.           Tokyo                Japan

I was also interested in non-local test server. This was trickier, but I found an Ookla XML feed that returns different lists based on your location. So I checked that while on a US VPN to get a second server ID.

With two IDs handy, I set up a cron job and that was it:

$ cat /etc/cron.d/speedtest
10 * * * * root (/usr/local/bin/speedtest -s 42297 -f json; /usr/local/bin/speedtest -s 10979 -f json) >> /var/log/speedtests

Setting up filebeat

The basic configuration if filebeat was simple. Just this:

$ cat /etc/filebeat/filebeat.yml
cloud.id: "(your deployment's cloud ID)"
cloud.auth: "(your cluster's user):(your cluster's password)"

filebeat.inputs:
  - type: log
    enabled: true
    paths:
      - /var/log/speedtests*
    scan_frequency: 1m
    json.keys_under_root: true

Getting filebeat set up on the Raspberry Pi was much more complicated. Elastic doesn’t have official binaries on the download page, so I ended up compiling from source. This required golang >= 1.16 which also isn’t available from Raspbian’s apt repositories. So I did this the old fashioned way.

First grab the armv6 version of golang, unpack that into $HOME.

Export the go path to where you extracted it and go binaries onto your shell path:

$ export GOPATH=$HOME/go
$ export PATH="$PATH:$HOME/go/bin"

Grab the beats source and get into the filebeat directory and run make:

$ git clone https://github.com/elastic/beats ${GOPATH}/src/github.com/elastic/beats
$ cd ${GOPATH}/src/github.com/elastic/beats/filebeat
$ make

Finally put the resulting binary into your path:

$ sudo mv filebeat /usr/local/bin/filebeat

If you ran into build trouble, feel free to post a note on the filebeat forum. You can even mention me, though I suspect other engineers will jump in before I even notice.

And finally I set up a systemd service to keep it running. I originally extracted this definition from the filebeat deb package and modified the executable path.

$ cat /etc/systemd/system/filebeat.service
[Unit]
Description=Filebeat sends log files to Logstash or directly to Elasticsearch.
Documentation=https://www.elastic.co/beats/filebeat
Wants=network-online.target
After=network-online.target

[Service]

Environment="GODEBUG='madvdontneed=1'"
Environment="BEAT_LOG_OPTS="
Environment="BEAT_CONFIG_OPTS=-c /etc/filebeat/filebeat.yml"
Environment="BEAT_PATH_OPTS=--path.home /usr/share/filebeat --path.config /etc/filebeat --path.data /var/lib/filebeat --path.logs /var/log/filebeat"
ExecStart=/usr/local/bin/filebeat --environment systemd $BEAT_LOG_OPTS $BEAT_CONFIG_OPTS $BEAT_PATH_OPTS
Restart=always

[Install]
WantedBy=multi-user.target

And enable the service.

$ sudo systemctl enable filebeat

Now if you have any tests in /var/log/speedtest, they should end up in filebeat-* in your Elasticsearch cluster.

A little more involved than docker compose up, for sure. But now we have a much more stable setup plus all the facilities of kibana at our disposal for analysis.

Graphing

There’s a bunch of data in the speedtest CLI JSON payload, but I was mainly interested in looking and downstream and upstream speeds over time.

The speeds recorded were a bit confusing at first. The main parts of the data look like this:

{
  "type": "result",
  "timestamp": "2021-10-12T05:10:16Z",
  "ping": { "jitter": 1.218, "latency": 8.1850000000000005 },
  "download": { "bandwidth": 3457698, "bytes": 15579024, "elapsed": 4404 },
  "upload": { "bandwidth": 5292178, "bytes": 23912512, "elapsed": 4502 },
  "isp": "ARTERIA Networks Corporation"
}

That download.bandwidth number is listed in bytes per second, but ISPs usually sell in megabits per second (Mbps). Thankfully Kibana lens now has formulas, so the conversion is easy. Just divide by 8, then 1000000. Or here I’ve used multiply to keep the formula short and simple.

multiply(median(download.bandwidth), 0.000008)

Same for downstream and we’re in business!

Results and Conclusion

With data in hand I can now see when my internet speeds get slow (mostly noon and 9p) and plan accordingly. Also interesting is that my upstream stays consistently high.

Once the covid situation calms down I may contact my ISP about other options, but I suspect issue extends beyond just my local ISP.

If you’d like to use the same dashboard, I’ve exported it here for import into your own kibana: internet-speeds-dashboard.ndjson

Dealing with MacBook CPU throttling

2021-09-03T00:00:00+00:00

About two months ago, I switched from the Elastic Cloud SRE team to one of the Kibana software teams at Elastic. This has had me using a lot fewer cloud instances and a lot more of my local laptop CPU.

Elastic gave me a fairly new MacBook Pro (16-inch, 2019), with a 2.4 GHz 8-Core Intel Core i9 and a whopping 64 GB 2667 MHz DDR4. By all means this computer should be crazy fast. But when I ran yarn kbn bootstrap for the first time, my computer was terribly slow. Even typing in my local slack app was lagged like I was on a bad SSH connection.

So I started trying to figure out why.

Googling macbook pro throttling led me quickly to this apple toolbox post which recommended checking like this:

❯ pmset -g thermlog
Note: No thermal warning level has been recorded
Note: No performance warning level has been recorded
2021-09-03 13:22:05 +0900 CPU Power notify
	CPU_Scheduler_Limit 	= 100
	CPU_Available_CPUs 	= 16
	CPU_Speed_Limit 	= 34

Ouch. 34 looked pretty low.

Next I tried the Hot app, which at least told me when I was throttling, but not much about why. Also the temperature was quite a bit lower than I expected.

So I tried Intel Power Gadget next. This had a lot more detail, I still couldn’t work out the reason for the throttling. I’d read about possible external display problems so I unplugged it and saw my CPUs jump back.

I tweeted this out and it started a nice thread that led me to consider my discreet GPU.

After a bit more digging, I found XRG which included configurable temperature sensor graphs, including the dGPU.

With some new tools in hand, I started working and sure enough I could see that the throttling kicked in when my dGPU got up to around 80C.

About this time, I also needed to do some work on VirtualBox which conflicted with the Intel Power Gadget. So I found this as a replacement to watch my core speeds, which XRG couldn’t.

❯ sudo powermetrics --samplers cpu_power | grep 'CPU Average frequency'
CPU Average frequency as fraction of nominal: 105.85% (2540.51 Mhz)
CPU Average frequency as fraction of nominal: 97.23% (2333.44 Mhz)
CPU Average frequency as fraction of nominal: 105.58% (2533.88 Mhz)
...

The throttling is actually easier to spot this way because all the cores will sync to the same reduced clock speed even when processes are putting demand on the CPU.

CPU Average frequency as fraction of nominal: 75.00% (1800.00 Mhz)
CPU Average frequency as fraction of nominal: 75.00% (1800.00 Mhz)
CPU Average frequency as fraction of nominal: 75.00% (1800.00 Mhz)

Now I’m far from a hardware heat-management expert here. But from various posts I can see that the CPU and GPU share a heat sink. And the dGPU is required to drive the external display. So what seems to be happening is that when display is plugged in, the dGPU starts heating up. If the system decides the GPU is too hot for the CPU to cool itself, it slows down the CPU to avoid overheating and potential damage.

Of course, I’m glad I still have a working laptop, but I’d also like to have a fast laptop :)

So far the best workaround I’ve found is the combination of a cooling stand (with fans) and keeping the air conditioning a little uncomfortably cold.

Or if I can live without my external display for a bit, I’ll unplug it and work on the laptop display. Usually until whatever big CPU job (often kibana bootstrap or optimizer work) is done then I can plug it back in.

I’d love to take it to the Apple Store to check if the fans are okay. It could be they’re dusty as Sergey Stadnik found in this post. But my location, COVID19 and vaccine shortages eliminate that possibility.

Maybe next year 🤞

Uninstalling Docker Desktop for macOS

2021-09-01T00:00:00+00:00

This morning, like many developers, I woke up to an email telling me that Docker Desktop would now require a subscription for me to use at work.

While I’m sure my company could handle the expense, I wasn’t happy to about the likely overhead and wanted to explore my options.

So I took a deep breath and hit the uninstall button.

This part was easy. But how should we get docker functionality back?

Docker Machine is an option I’ve used before Docker Desktop and it doesn’t seem to be covered under the new licensing requirements. It’s also available via homebrew, so it’s an easy option to try out.

The basics

# Install it
brew install docker-machine

# Provision a default machine
# My docker desktop was set to 12GB of memory, and I'm setting disk to 100GB to accommodate the many images I have to work with.
# Please adjust for your machine.
docker-machine create --virtualbox-cpu-count 4  --virtualbox-memory 12288 --virtualbox-disk-size 102400 default

# Add this to my zshrc to export the env if docker-machine is present
command -v docker-machine > /dev/null 2>&1 && eval "$(docker-machine env default)"

Docker Machine doesn’t come with a docker CLI client so brew that as well.

brew install docker

And seems like we’re in business.

❯ docker ps

CONTAINER ID   IMAGE     COMMAND   CREATED   STATUS    PORTS     NAMES

Running docker compose

Next I’ll try a docker compose test tool I often use.

❯ docker compose -f create-certs.yml run --rm create_certs
unknown shorthand flag: 'f' in -f

Interesting. The brew installed docker CLI doesn’t include the fancy new compose subcommand that docker desktop does.

Well, that’s just a brew away:

brew install docker-compose

And my previous docker compose workflows seem to work just fine.

❯ docker-compose -f create-certs.yml run --rm create_certs
# Good stuff happening

❯ ELASTIC_VERSION=7.15.0-SNAPSHOT docker-compose up
# Mostly good stuff, but then this
node01        | ERROR: [1] bootstrap checks failed. You must address the points described in the following [1] lines before starting Elasticsearch.
node01        | bootstrap check failure [1] of [1]: max virtual memory areas vm.max_map_count [65530] is too low, increase to at least [262144]

The elasticsearch docs cover the sysctl setting I’ll need to correct this. But how do I get that into docker machine?

Thankfully I came across github.com/boot2docker/boot2docker#1216 which has the info I need. Amusingly for the same Elasticsearch memory requirement.

❯ docker-machine ssh default
...
docker@default:~$ sudo -i
# Set it for the current runtime
root@default:~# sysctl -w vm.max_map_count=262144
vm.max_map_count = 262144
# Put it in the profile for next boot too
root@default:~# echo 'sysctl -w vm.max_map_count=262144' >> /var/lib/boot2docker/profile

I restarted the docker-compose command and things are looking better.

Finally, let’s load up the kibana inside the docker-compose stack I just started.

No love. Since docker machine runs a VirtualBox VM, the network space isn’t shared with my OS.

But docker machine can tell me the IP I need easily enough.

❯ docker-machine ls
NAME      ACTIVE   DRIVER       STATE     URL                         SWARM   DOCKER      ERRORS
default   *        virtualbox   Running   tcp://192.168.99.100:2376           v19.03.12

What about kubernetes?

I also had a kind based tool I needed to run. So let’s try that:

❯ brew install kind kubectl
...
❯ kind create cluster
Creating cluster "kind" ...
 ✓ Ensuring node image (kindest/node:v1.21.1) 🖼
 ✓ Preparing nodes 📦
 ✓ Writing configuration 📜
 ✗ Starting control-plane 🕹️
ERROR: failed to create cluster: failed to init node with kubeadm: command "docker exec --privileged kind-control-plane kubeadm init --skip-phases=preflight --config=/kind/kubeadm.conf --skip-token-print --v=6" failed with error: exit status 1
Command Output: I0901 23:58:29.674676     210 initconfiguration.go:246] loading configuration from "/kind/kubeadm.conf"

More bumps.

For this one I managed to google my way to github.com/microsoft/WSL#4189 which mentioned that missing systemd could be an issue. So I’ll try that fix.

❯ docker-machine ssh default
   ( '>')
  /) TC (\   Core is distributed with ABSOLUTELY NO WARRANTY.
 (/-_--_-\)           www.tinycorelinux.net

docker@default:~$ sudo -i
root@default:~# mkdir /sys/fs/cgroup/systemd
root@default:~# echo 'mkdir /sys/fs/cgroup/systemd' >> /var/lib/boot2docker/profile
root@default:~# mount -t cgroup -o none,name=systemd cgroup /sys/fs/cgroup/systemd
root@default:~# echo 'mount -t cgroup -o none,name=systemd cgroup /sys/fs/cgroup/systemd' >> /var/lib/boot2docker/profile

This did the trick to get kind booted normally. But of course, more trouble:

❯ kubectl cluster-info --context kind-kind

To further debug and diagnose cluster problems, use 'kubectl cluster-info dump'.
The connection to the server 127.0.0.1:57999 was refused - did you specify the right host or port?

To fix this up we’ll need to create kind with the right server address. So we’ll create a kind.yaml.

kind: Cluster
apiVersion: kind.x-k8s.io/v1alpha4
networking:
  apiServerAddress: "192.168.99.101"
  apiServerPort: 57999

The IP address here is from docker-machine ip and the port number is whatever the last attempt’s error used.

Strangely enough if you don’t specify a port, it will fail to assign a random one:

ERROR: failed to create cluster: failed to get random host port for port mapping: listen tcp 192.168.99.101:0: bind: can't assign requested address

With the config in place I was able to get kind booted with kind create cluster --config kind.yaml and finally run a successful kubectl apply.

Wrap up

It’s not perfect. A few clear cons:

I’m missing the fancy new docker compose subcommand.
I have to keep VirtualBox installed functional. This can be a pain especially since last I checked it conflicts with the Intel Power Gadget.
I can’t use localhost which may cause link confusion between me and co-workers.
The docker-machine VM needed a some tweaks for some software packages (elasticsearch, kind). I suspect there’ll be more as time goes on.

But it should do the job at least.

If my company ends up buying Docker Desktop licenses tomorrow, I’ll surely go back. But I’m glad I have this post handy to refer back to should I need it.

I’ll post updates as I find out more. Thanks for following along with me!

2021/09/02: Added section on kind & kubernetes

A Startup Weekend retrospective

2015-10-20T00:00:00+00:00

The Nagoya Startup Weekend this year was exhausting yet rewarding.

To cap off the effort, I thought I’d write up a quick retro.

Things that worked

First, hats off to the organizers. Fantastic event, very well organized.

If you’re organizing a similar event, I’d recommend paying similar attention the the details that ours did so well, namely:

snacks, plenty of them
music, easy to listen to and a wide selection
breaks, for facilitator talks and games

The talk breaks were especially good for helping everyone keep synced and giving some perspective about where we were in the weekend.

They also provided good advice about how to approach the weekend in general.

One that really stuck with me is that “this is not a hackathon” - which I think the organizers of Bobby Boyd’s hackathon probably missed.

Teams seemed to take this to heart and had a great showing without working code. Instead they leaned on deeper market analysis, clickable wireframes and more details around potential business and revenue models.

Another thing that worked really well were my friends and family. I got a lot of response and participation from friends and family via facebook. I can’t thank everyone enough for that.

Things that didn’t work so well

First here, following in that “not a hackathon” vein: I don’t think I worked very well.

Granted, I got a lot done. I focused mostly on coding and we had a fully functioning prototype by day 2. This was great fun for me but I think this was actually a detriment to the team.

While focusing on the prototype I couldn’t offer much input on strategy. I think also having such a complete prototype may have anchored the team at a time when changes were needed.

The next thing I could see changing was the coach involvement. We spent some time with the coaches in organized sessions, but it felt like it came a bit late.

I would have loved to get some of their feedback earlier, perhaps even continually in the form of challenging interjected questions during early planning and discussion.

Wrap up

It was a great weekend over all. I met a ton of people, learned some new techniques and learned a lot about my own interests in developing products.

The discovery I was especially proud of is that I like coding way better than market analysis & experimentation. While it’s probably no surprise to those who know me, I think knowing this empirically will really shift my approach to startup ideas going forward.

If you’re planning on attending one yourself, I’d recommend coming with an idea of your own, plenty of business cards and a grab bag of tactics for gathering early customer feedback.

I suspect these will serve you and your team better than the freshly updated set of rails gems I showed up with.

If you have any thoughts or experiences from your own start up weekend, or questions about mine please leave a comment!

First look at Otto and Nomad

2015-09-29T00:00:00+00:00

The big one, Otto

Otto is a tool that wraps up Vagrant, Packer, Terraform and Consul and provides clean layer of abstraction on top.

This provides a seamless way to transition from your local environment, into a dev VM on VirtualBox, then on to an instance on AWS. The same Appfile is used on both environments then fed through either Vagrant locally or Packer & Terraform on AWS.

In addition Hashicorp has built in infrastructure and foundation concepts that configure VPC and supporting services (right now just Consul) automatically as well.

Finally it comes with a nice app detection suite that’s capable of building a default Appfile for a good range of application frameworks.

A few surprises

The getting started guide was really straight forward but I did hit a few surprises that I’m sure will get worked out over time:

The VM that got selected in the tutorial was Ubuntu 12.04. It worked fine but I was pretty surprised to see such an old release used here.
Otto doesn’t use ~/.aws/credentials for AWS credentials. Instead it prompts you for credentials and a password to encrypt them. Not a deal breaker, but was a bit curious given how common the AWS credentials file is across tools these days.
Packer chooses a c3.large to build the AMI by default. The build should be less than an hour so it won’t cost much but it won’t qualify for the free tier if you’re trying to keep your AWS bill at zero.

The takeaway

Otto, quite frankly, looks awesome. I can’t wait to see where it goes from here.

I’ve already got the code checked out and am exploring what it’d take to build some sort of monitoring foundation like Influx or Netflix’s Atlas.

I’d also love to see some evolution in deployment strategies, specifically in the direction of rolling ASGs similar to how Netflix’s Asgard tool does it.

To wrap it up I did a quick screencast of the high-level steps that the getting started guide goes through.

Also, Nomad

I also took a peek at Nomad which was the other HashiCorp release yesterday.

This is a scheduler project that aims to make running containers across a fleet of docker hosts straight forward.

While Otto seemed to be a very new piece of software, Nomad felt similar to other container management tools such as Kubernetes or CoreOS Fleet.

The getting started guide again was fairly solid though I did run into a few cases where I had no contianers running and couldn’t figure out why Nomad wasn’t scheduling them.

Nomad appears to still be a bit more beta than Otto, but there are hints that Nomad will provide a platform for Otto in the future.

This would be a welcome addition since it should offer a way to deploy containzerized apps much more quickly than the current AMI-baking default.

Congrats to the folks at HashiCorp for a very big and well-executed release day!

What should I monitor?

2015-01-14T00:00:00+00:00

It’s an old question. And one that can vary quite a bit from domain to domain.

But for Web Operations there are some definite patterns I’ve come across. Most of these come from the last two years I spent working as a Reliability Engineer at Netflix. Even though we had hundreds of discrete applications when something broke you often found yourself looking at similar sets of metrics.

So without further ado, here they are, broken down per category and in a roughly-prioritized order.

The basics

Successful requests per second
Failed requests per second

Successful requests in the HTTP world take the form of something in the 100s-300s. Failed HTTP requests would usually be anything 400 and above. Most services have some way of designating “yes it worked” vs “no it didn’t”. Count those.

Ideally count them from both the client and server side. For middle-tier services the client-side counting can often go in a common client library, edge services may be able to count at the load balancer. If counting at the client isn’t feasible you can count at the server side only, but in that case you run the risk of missing unseen failures due to networking trouble.

You can then make a ratio out of these (failures / successes) * 100 and start tracking your availability against an error budget.

If possible, break these down on a per-resource basis (in the REST-resource sense). Not all monitoring tools can provide this sort of tagging but being able to say which resource is very valuable when trying to deduce what’s wrong. This will often take the form of the first part of the HTTP path or the controller object that’s servicing the request.

Deeper errors

Errors when calling back end services
Unhandled exceptions
Known application-specific error conditions (e.g., locked account)

Not all error conditions manifest as a failed request. Typically a service has circuit breakers, fallbacks, or other mechanisms to deal with internal failures without causing a user-visible error. But you’ll want to count them even if the user doesn’t see them.

Watching for changes in deeper error trends can tell you when something is about to go wrong or when something is going wrong in a way that you can’t see from your basic metrics.

For example, you could have a failed remote call which causes key data to be omitted from the returned data. This would still be a 200 but the client may not be able to use the response.

Count these on a per-second basis with some low-cardinality break down. Many systems have a set of internal error codes which will likely be reusable as a way to break down deeper error counts. Or in the case of circuit breakers, the name or class of the circuit is typically a good way to segment these errors.

Tracking performance

Latency distributions

Now you may have a system which is always returning 200s, but if it goes from 150ms response times to 4000ms response times, you have a problem.

In addition to a simple max, min and average per second, percentile distributions are common here. You can start by looking at the 50th, 95th and 99.5th percentile which many tools (e.g., statsd) support. Bucketing by time (e.g., < 10ms, 100-500ms, > 500ms) is also useful since bucketed counters can be averaged across many servers and still retain some accuracy. Averaging the 95th percentile across a hundred machines is still useful, but doesn’t tell you your actual 95th percentile for the whole fleet. Unfortunately this bucketed approach is a bit less common probably since it requires you to have a sense of how your service will perform ahead of time.

Much like the success counters, you’ll want to break these down by resource if possible. Knowing where the latency is coming from can point you in the right direction a lot faster. If all resources are effected equally, investigate the system showing the latency. If it’s a single resource, investigate the systems used to build that resource’s response data.

OS & Runtime level metrics - the USE method

CPU
Memory & Garbage Collection
Disk
Network

Of course, these are important to keep an eye on as well. But how their used will vary quite a bit between services.

On the plus side there are many good tools and resources for monitoring this stuff since most any environment will be capable of providing metrics on it.

Rather that get into details here, I’ll refer you to the USE method from Brendan Gregg which is a really solid place to start when examining OS level resources.

In some respects the metrics discussed above are Brendan’s USE method re-applied to distributed systems.

Utilization - how many requests are coming in?
Saturation - are the requests backing up and becoming latent?
Errors - what errors were encountered servicing requests?

So if you should find yourself in an unknown domain wondering what to monitor, try the USE method there too.

Next steps - tooling

There are a number of software packages that can help you track the sort of metrics covered here so I won’t try to cover them in detail. But if you’re really just getting started here are a few options I’ve had experience with:

Statsd -> Graphite

I did a screencast on this approach almost a year ago. It’s a fully open-source approach that’s quite common and has a large ecosystem.

Zabbix

The Stellar setup is mainly using this right now. It’s also open source and has a rich feature set, but the surrouding ecosystem a a bit limited.

MRTG

I’m not as familiar with MRTG, but it’s been around a very long time and is still cited as one of the easier monitoring setups to get started with.

Atlas from Netflix

The system I’m most familiar with. I’ve seen it cover all of the above items while working at Netflix, but the open source offering is still new and somewhat raw. I look forward to more experimentation and blogging around Atlas in the near future.

Conclusion

As stated above, metrics and monitoring can be a very application-specific thing so consider everything in the context of your application and infrastructure. My hope is that for those of you still defining your operational metrics, this will provide a good basis for growing your own distributed system.

If you have any comments or examples from your own system, I’d love to hear them. Feel free to leave a comment below or come find matschaffer in #stellar-dev on freenode.

It's war out there. Get yourself a sub.

2014-12-28T00:00:00+00:00

When I started at Netflix almost two years ago, one of the first things that occured to me was “We could really use a general helper command.” Other developers even agreed that it could be handy. I recalled Nick Quaranto’s handy sub repository but with Netflix being a Java shop, I wasn’t sure about introducing something that required a bash environment.

A few months passed while I tinkered with doing something in Groovy. Then during one of our hack days I gave in and decided to use sub to make an nf command. With only a few commands in place, it quickly became part of my daily workflow. When I started at the Stellar Development Foundation I decided to start a sub command on day one. Even with just two commands I already use it daily.

So what’s this “sub” thing about?

Sub is a project from Nick Quaranto that lets you build collections of scripts and access them via git-like subcommands. If you use rbenv you’re actually already using sub. The really cool part is that you can also make your own.

Need a helper to start up an ssh tunnel? It’d look like this:

#!/usr/bin/env bash
# Usage: mysub tunnel
# Summary: Sets up an ssh tunnel
# Help: Requires ssh and access to jumpbox, etc, etc...

set -e

ssh -NL 8888:somehost:80 me@jumpbox

You drop this script in mysub/libexec/mysub-tunnel and sub provides access to it via mysub tunnel.

Just providing access to the script via your custom command is handy. But sub takes it a step further with tab completion (for both bash and zsh), command listing, and documentation access for free. Sub parses everything it needs from the comments at the top of your script.

While I could go into more detail about all of sub’s capabilities, the readme is pretty solid so go check it out. If you have any sort of repetitive commands you use, give it a try. Commit it to your company repo and your coworkers will thank you for it.

As a final note, don’t let the age of the last commit cause hesitation. I’d of course love to see more activity on the project, but it’s a simple enough concept and I haven’t run into any problems using it as a daily tool.

Rethinking My Kanban Board

2014-06-16T00:00:00+00:00

If you’ve ever used Trello, Jira, or other kanban board tools you may be used to seeing a board that looks like this:

Note: The ticket names have been changed to protect the innocent.

Here we have a typical 3-column layout; To Do, Doing, and Done. Our three available “dimensions” represent the following:

Vertical: Priority
Horizontal: Status
Color: Logical track of work

The use of color may vary a bit depending on project, but there are number of systems that work this way and I’ve grown really used to it. Though it can have some problems, namely:

There are only a few colors to work with, so you can run out on complex projects
There’s only one “top” of the list, so if you have many people working the list may thrash a bit
If groups are fairly separate, people may need to skip down the list to find the next ticket they should work on

Of course these cases are somewhat rare and manageable so I happily kept working in this model. Jira also makes this easier since I can build filters to just see the parts of the board I was actively working on.

But when I showed up at the Trello board for a project I joined recently, I saw this:

Oh, man.

How would I know what the status of a ticket was? How do I separate my backlog from my completed work?

Here the horizontal dimension typically used for status has been replaced with the track of work breakdown. My coworker said he laid it out this way because he’s how he thought about the project. I considered “pivoting” it back to what I was used to, but the project already had more tracks of work than Trello had available colors.

Then it dawned on me: the only status I was really concerned about was “Doing”. This was easily represented by a color. And with all those other colors available I decided to use two to represent my typical use of story points: 0 for trivial, 2 for easy, 4 for hard.

Now the board looked like this:

Now our dimensions look like this:

Vertical: Priority
Horizontal: Logical track of work
Color: Status & Difficulty

Notice that we’ve added a little extra information and now have the option to introduce more than 6 tracks of work.

We also added an “Ideas” column on the left for higher level ideas that still needs to get split out into the different tracks of work. And a “Done” column far off to the right to get the completed tickets out of the way.

We’re still iterating on this a bit, like ya do. But I’m pretty happy with how it turned out and really glad I didn’t just try to force my preconceptions onto the existing board.

Thoughts on Scalability

2013-09-30T00:00:00+00:00

I spent the last two years doing deployment automation work and helping startups build Rails applications at Mashion. It was great fun but rarely put me in the path of high-scale customer traffic. Getting close to that traffic was a big factor in my decision to move west and help run one of the largest installations on the internet.

Since I joined Netflix last April there have been a number of interesting things I’ve learned about how we operate at high scale. Some of these seem obvious but were never quite at the forefront when working on 3-tier startup applications.

Backward compatibility on all fronts

In a start up, you can take usually the app off-line for a few minutes overnight. No-one will notice or be upset. When you’re working on a full-scale product the traffic never stops so you have to rethink how you do your deployments.

You will usually have two (or more) versions of your application code running at any time. You will usually have application code running against older client code or database schema. Most changes have to be done gradually. It pains me to think how difficult this would be with a typical Rails application. The facility to run and test against multiple schemas just isn’t there.

I hope rich-client applications push the needle on this one since you need to address the possibility of an unrefreshed browser session hanging out there. Granted, most of the rich client frameworks don’t ship with an answer to this yet. But I suspect it’s only a matter of time until they do.

Runtime controls

In an average Rails app, if something isn’t right with a new feature, you redeploy. When you have a few hundred or thousand machines a full redeploy can take awhile. So instead you need a way to control your app at runtime. Usually this takes the form of feature toggles.

At Netflix we use archaius for this but there are many projects that can help provide this functionality. But it’s critical that you have a quick way to turn off broken features or slowly roll out new features.

App-level focus

When I ran servers in the past I would often obsess about the operating system, the file system structure, which HTTP server or daemon tool we used. Now that I work with a few hundred machines at a time, most of that has fallen away. I find myself mentally equating servers and processes.

There are a lot of processes running on each machine but the main one I care about is the one handling customer requests.

It has taken me some time to learn to relax and love my base image. But I’m happy that I have. It may not be exactly how I’d do it but at our scale that really doesn’t matter.

Auto-scale everything

I’ve been using AWS for a long time. But this usually meant creating one-off EC2 instances and provisioning them over SSH. Each one then stayed online as long as it could as I upgraded, re-deployed and otherwise tweaked the server.

This is data center mentality.

To really leverage the cloud you need to be in an auto-scaling group. This will ensure that servers are easily replaced as they come and go (and they will). It also forces you make your application resilient against failures. Failures can happen anywhere but only the cloud approach offers a way to fully recover from failure automatically.

These points are really just a sample of the things I’ve been learning recently. Hopefully they provide some food for thought. The Netflix stack certainly has a number of components that can help with these items but there’s plenty of room for improvement. Especially when it comes to bridging the gap between high scalability and rapid application development.

Rebooting

2013-09-08T00:00:00+00:00

So what happened last year?

I taught Rails at UPenn

I taught a full year of CIS196 at UPenn. Being an adjunct teacher was great and highly recommended to anyone interested. The skills I learned on presenting, course organization and mentoring keep coming in handy again and again.

I took a full-time job at Netflix

This was a tough move but consulting just wasn’t teaching me much about technology. I learned tons about business operations and project management. I’m sure I’ll make good use of all this at some point but for now I really wanted to double down on my tech education. There were definitely a lot of takeaways from the business side, but I’ll save those for later posts.

I moved to San Jose

This was a prerequisite for the new job. But honestly it’s like Hollywood for programmers out here and the weather is jaw-droppingly amazing.

Also working at Netflix has been perfect. I can’t think of a better place to learn about high-scale software development.

I rebooted this blog

The above points got me wanting to write again. One thing that I think we lost sight of at Mashion is how important writing is to a personal brand. The traffic on posts themselves is great but the writing process also helped me solidify a number of ideas both technical and non.

So here goes. I’m going to try to write a bit more regularly on some of my findings now that I’m back in the high-scale world in the heart of Silicon Valley. Wish me luck!

Mashion's Pairing Rig

2012-07-20T00:00:00+00:00

Here at Mashion, we pair program a lot. We’ve been iterating through a handful of pairing setups and have finally settled on what I’m happy to call a masterpiece. But first, a little bit about how we got there.

We decided that having a dedicated pairing machine wasn’t practical, partly for price but also because we’d have to maintain another machine and the data on it. Instead, we opted to use our own laptops to power all of our pairing rig iterations. This also makes for a smooth transition from pairing to soloing since you’re able to plug and unplug and the only thing that changes is your screen size.

Originally, we paired side-by-side using a shared single monitor. This worked reasonably well. It’s simple to get started and offers a balanced environment between the two partners. But being off to the side of the monitor is bad ergonomics and having a face-to-face conversation doesn’t work very well. Noticing that your partner is trying to type is also harder and you bump chairs a lot more often than you’d think because both partners tend to lean toward the shared display.

Then we switched to face-to-face pairing on a single desk. This worked better, but since we still only used one display, one coder would be on their laptop. This mismatch was awkward and again not great ergonomics. In exchange, we got good face-to-face discussion, easier non-verbal cues and no chair bumping. Although we did get occasional games of footsie. If you’re setting up pair programming with limited time or resources, I’d definitely go this route first. The desk here is an Ikea Galant, which I’ve seen at a number of offices in the past couple years.

At this point we really wanted to address the environment parity problem. We wanted two monitors, but how could we mirror two displays off of one MacBook? Most solutions to this were expensive and bulky. Thankfully Jason Garber joined the team around this time and had a stroke of genius: Use HDMI splitters which were small, cheap and easy to attach to a laptop. This was the key that let us drive two identical environments off of one standard laptop.

To really put the icing on the cake, we took a cue from Pivotal Labs’ tete-a-tete pairing article and started working on ways to offset the pair to get better communication. The solution that Greg Sterndale came up with was also genius. He noticed out that you can use a Galant extension as a single desk. Put two of these together and you have two individual desks that take up a little less space than the single larger Galant desk. Total win! Also a lot less footsie

Finally we finished it off with easily-movable monitor mounts, wireless input devices and some cable clips to make a pairing rig that’s there when you need it and gets out of the way when you don’t.

This setup is by far our best setup yet. The closer seating makes for easy conversation even when the floor gets busy. Each coder gets their own space which is just big enough to get the job done. Having the monitors mounted on the outside also makes them easy to move aside when splitting off to do some research or other solo task. And we get some epic high-five action when the test suite goes green.

If you like the idea, check out our Amazon Wishlist to get all the pieces. If you make one, be sure to send us a note and tell us about your thoughts or improvements!

A paragraph on sexism in computer science

2012-04-24T00:00:00+00:00

Trevor encouraged me to write a paragraph on sexism in computer science and how we can change it. I encourage you to do the same!

Here’s mine:

Angela Harms had a great quote on her recent appearance on the Ruby Rogues podcast. It’s been ringing in my head all month: Stay present, stay vulnerable.

I think it applies in a lot of situations and sexism in the work place is one of them. The news I’ve seen on the topic lately tends to be a situation that could have been avoided if people weren’t trying to be cool or save face. We already build the most complex things that humans make. No need to act cool or demean your co-workers. We’re all smart here. Stay present, stay vulnerable.

Run CI locally on Jenkins

2012-04-06T00:00:00+00:00

At Mashion our usual pairing setup means we have one laptop that’s not doing much work. It’s handy to have for email, or breaking off to google something but it’s idle most of the time.

When looking for a CI solution on a recent project, it made sense to me to use that second machine rather than spend money on a VPS. So I set out to make a simple local Jenkins server. Here’s what I came up with.

First install the jenkins.rb gem and start the server:

gem install jenkins jenkins-war
jenkins server --daemon

Once the server is up and running (check localhost:3001) use the Java Jenkins CLI to install the git plugin or whatever plugins you need for your setup.

CLI=$HOME/.jenkins/server/war/WEB-INF/jenkins-cli.jar
java -jar $CLI -s http://localhost:3001 install-plugin git
java -jar $CLI -s http://localhost:3001 safe-restart

Once Jenkins restarts you’ll probably want to set up outbound email. I did this using my gmail account and these instructions on the Jenkins wiki. Do this on the Jenkins config page.

jenkins configure --host localhost --port 3001
jenkins create path/to/project --template none

Here I opted not to use a project template. The ones that come with jenkins.rb don’t poll Git or email on failures. I also prefer keeping the build steps in script/ci in the project’s git repo since it’s easier to update and port across languages and frameworks.

So head to your Jenkins server and configure your job to poll git every 5 minutes with this cron expression:

*/5 * * * *

Replace the echo build step with script/ci. And add an E-mail Notification to yourself or whoever should know about failures (space separated). Then save your job config.

You’re all set. Commit some new code or click the “Build Now” link to run a test build. To stop the Jenkins server run:

jenkins server -k

Hope that helps some, feel free to leave a comment or email me if you have any questions.

Creating a minimal Ubuntu VirtualBox image

2011-06-29T00:00:00+00:00

Update 2015/01/14: This post is from 2011! If you’re looking for a minimal ubuntu running on VirtualBox I highly recommend you check out Vagrant. Once you have it installed you can get a minimal Ubuntu box running with two easy commands

$ vagrant init ubuntu/trusty64
$ vagrant up

The instructions below still might work, but have only been tested on 10.04 LTS which is quite old at this point.

In my last post, I showed you how to build a CloudFoundry mini-cloud on an Ubuntu VirtualBox. Building that base image took some work and sorting through old blog posts, so I thought I’d post the instructions I ended up using.

First, download a copy of the latest Ubuntu LTS (Long-Term-Support) image. This tutorial follows the 10.04 installation, later versions may vary.

At the boot screen, press F4 which will let you select the type of installation to perform. Select “Minimal Virtual Machine”, then hit enter to start the Install.

Keyboard selection won’t matter much, so I just chose USA/USA.

For the system clock, I recommend UTC. This models most of the cloud provider images you’re likely to come across.

Have it use the whole disk and auto-partition.

Use ‘ubuntu’ for the username and password for now. Once the system is set up, you can install your ssh keys and remove the password with sudo passwd -d ubuntu.

Disk encryption and HTTP proxies is your choice, but I didn’t need to use either.

When you get to select packages, do manual package selection and it will put you into the aptitude program. This is a little tricky to navigate, but these commands should be plenty to get the job done:

use /, enter and n to search similar to less or vi
+ to install the selected package
search and install as needed
gg to install packages

You’ll need these packages in order to get the VirtualBox guest tools setup. I recommend installing these since it will enable you to detect the IP of the VM and shut it down without having to SSH into it:

build-essential
linux-headers-virtual
openssh-server

Once it reboots, select “Install Guest Additions” from the Devices menu to mount the VirtuaBox guest additions install image. Then log in and run these commands:

sudo mount /dev/cdrom /mnt
sudo sh /mnt/VBoxLinuxAdditions.run

The last important fix is to remove the MAC address cache that this version of Ubuntu has:

sudo rm /etc/udev/rules.d/70-persistent-net.rules

Note that when you import the image using VBoxManage you should also reset it’s MAC address. You can do this using VBoxManage like this:

VBoxManage modifyvm MyVMName --macaddress1 auto

You may also want to be able to shutdown the machine without logging in, you’ll also need to install ACPI support:

sudo apt-get update
sudo apt-get install acpi-support

This will allow you to use the VBoxManage command to shut down the machine cleanly without using SSH:

VBoxManage controlvm MyVMName acpipowerbutton

If you want passwordless sudo access (also common on cloud images) run:

sudo su -c "echo 'ubuntu ALL=(ALL) NOPASSWD:ALL' >> /etc/sudoers"

At this point, disconnect the guest additions and shut down the VM. You should now have a super-minimal Ubuntu image that’s confiured similarly to the Ubuntu images you’ll see on cloud services like EC2.

Running CloudFoundry with VirtualBox on OS X

2011-04-15T00:00:00+00:00

So you might have seen the “one click” installer for CloudFoundry that my esteemed colleague Trotter Cashion posted yesterday. This is very cool. If you have an Ubuntu server handy you can run that script and you have a cloud. But I like to keep things local so I started working to get it installed on VirtualBox. And here’s the solution, packaged as a script.

To use this script you’ll need:

A Mac (Linux or Cygwin would need some tweaks, pull requests welcome!)
VirtualBox

Then run this:

curl -O https://github.com/matschaffer/vcap/raw/vbox-install/setup/vbox_install
curl -O https://github.com/matschaffer/vcap/raw/vbox-install/setup/install
sh vbox_install

Accept the host key (should be 5f:f4:1f:14:4c:b8:5c:ad:11:b1:85:f3:f1:0d:a5:2c) and enter the password “ubuntu” once.

That’s it! This script will import a minimal Ubuntu VM from our S3 bucket, set up bridged networking to your default interface, install your SSH key and kick off Trotter’s install script.

It’ll take an hour or so depending on your internet connection. When it’s done, you’ll get some instructions on updating your hosts file, registering with your new cloud and accessing the VirtualBox image. Follow those and enjoy your new personal cloud!

How to hire a Rails developer

2011-04-12T00:00:00+00:00

As the co-founder of Mashion and organizer of Philly.rb I get a lot of emails from people looking for Rails developers. To help spread the word and maybe do a little less typing, I decided it was time for a blog post.

Before we get into it you should know that finding a good developer in any technology is difficult. Even in larger developer pools like Java or .Net, isolating the top talent is difficult. The pool of Rails developers is of course smaller, but also contains some extremely high quality developers. Here are some of the key points I’ve settled on when helping people find the right developers for their company.

1. Get involved

There are probably some user groups near your area. Maybe even a Ruby user group. Google them, go to a meeting. This is easier when you know a little programming, since the conversation will be mostly technical. If you have even one developer now, send them. If you’re the only person in your company, just show up anyway. Establishing a presence in the community goes a long way. The more often people see you, the more likely your company will come to mind when people think about changing jobs.

This is a continuation of the first point. Being at the meeting is a great start. Being at the podium is even better. And it’s a bonus if you’re talking about cool technologies or business ideas. If no-one in your company can present on a technical topic, sponsor a meeting. Most groups accept sponsors for food, space, or giveaways. So you can probably find an option that works even if your budget is pretty tight. In exchange you’ll usually get mentions in the meeting promotions or a chance to talk about your company while everyone’s paying attention. This varies between groups, so contact the organizer for info.

3. Don’t talk about your degree

Whether it’s technical or business-related, most of what interests Rails developers doesn’t come from a classroom. People are much more interested in hearing about your experiences in real companies, delivering real products. If you don’t have any experience, that’s okay too. Just be honest about it. Rails developers are very aware that good business ideas can come from anywhere.

4. Have a business plan

How are you going to make money? Knowing your target market and having a marketing plan is best. Having a good shot at a buy out is passable. Selling advertising is unlikely to get anyone’s attention. If you’re profitable today, pitch that. If you’re not profitable yet, emphasize what your company has to offer in technology or lifestyle interest. Having VC backing is fine, but it’s not a big selling point. Same goes for equity offers. Most of us experienced what happened in the dot-com bubble and are not eager to repeat it.

5. Don’t hire a “Rails” developer

The best developers I know don’t classify themselves as “Rails” developers. They might do most of their business in Rails, but they also do JavaScript, Clojure, Erlang, Objective-C and a multitude of other languages. They have side projects using technologies even I haven’t heard of yet. The web development landscape changes rapidly, so you’ll need people who are constantly challenging themselves to learn more.

As with any blog post, these are just some ideas that have helped me. If you have some points of your own, please comment. I welcome the feedback.

Good hunting.

Net::HTTP Mocking during Cucumber Tests

2011-04-03T00:00:00+00:00

I just finished up an awesome week by speaking at RubyNation. Hats off to the organizers and the sponsors for throwing a great conference! During my twilio talk I mentioned how we had problems running Artifice during our @javascript Cucumber features. Here’s how that goes down.

If you’re trying to use any sort of global Net::HTTP mocking tool during your Cucumber tests, you might encounter something like this:

  Background:
    Given I am on the new user registration page
      Capybara::TimeoutError (Capybara::TimeoutError)
      ./features/step_definitions/web_steps.rb:20:in `/^(?:|I )am on (.+)$/'
      features/user_registration.feature:7:in `Given I am on ...'
    Then I should see "Email"
      Capybara::TimeoutError (Capybara::TimeoutError)

This happens because Selenium and Capybara use Net::HTTP to know when your Rails app is available. Sadly, you can’t even put the mock activation in a Before block because Capybara won’t start the separate Rails app until the first @javascript test. To get around this we set up our env.rb like so:

require 'artifice'
require Rails.root.join('test', 'support', 'fake_twilio')
Artifice.activate_with(FakeTwilio)

require 'capybara/rails'
require 'capybara/cucumber'
require 'capybara/session'

module Selenium
  Net = ::Net.dup
  module Net
    HTTP = Artifice::NET_HTTP
  end
end

class Capybara::Server
  Net = ::Net.dup
  module Net
    HTTP = Artifice::NET_HTTP
  end
end

In the case of Artifice, it holds on to the original Net::HTTP as Artifice::NET_HTTP. This block of code puts the original Net::HTTP back but only in the namespaces where it’s needed (Selenium and Capybara). Yet another lovely example of how powerful Ruby is. If you have a cleaner way to do this without resorting to two HTTP libraries, I’d love to hear it.

Making your own Ruby gem

2010-12-21T00:00:00+00:00

It’s easy to make your own Ruby gem. Even without a library to help you. If you have RubyGems installed you’re already good to go.

First, make a directory for your project. In that directory make gemspec file named after the gem. For example, my_awesome_gem.gemspec. The gemspec file is just Ruby. Here’s a basic example:

Gem::Specification.new do |s|
  s.name    = 'my_awesome_gem'
  s.version = '0.0.1'
  s.summary = 'This bit will show up under your gem on rubygems.org'

  s.author   = 'Mat Schaffer'
  s.email    = 'mat@schaffer.me'
  s.homepage = 'https://github.com/matschaffer/my_awesome_gem'

  # These dependencies are only for people who work on this gem
  s.add_development_dependency 'rspec'
  s.add_development_dependency 'mocha'

  # Include everything in the lib folder
  s.files = Dir['lib/**/*']

  # Supress the warning about no rubyforge project
  s.rubyforge_project = 'nowarning'
end

Now just put your code in lib/my_awesome_gem.rb. RubyGems will automatically put your lib directory into the load path when the gem is installed. To test your gem before it’s installed just run your test script using ruby -Ilib my_test_file.rb.

Now build your gem with gem build my_awesome_gem.gemspec and push it to RubyGems.org by running gem push my_awesome_gem-0.0.1.gem. You’ll need to make a RubyGems.org account if you don’t have one. The gem push command will ask you for your account info the first time you push a gem.

As a bonus, if you want to use rake to build and push your gem, just make a Rakefile like this (run rake -T to see what this gives you):

require 'rake/gempackagetask'

spec = Gem::Specification.load(Dir['*.gemspec'].first)
gem = Rake::GemPackageTask.new(spec)
gem.define

desc "Push gem to rubygems.org"
task :push => :gem do
  sh "gem push #{gem.package_dir}/#{gem.gem_file}"
end

And if you want to manage your development gems with bundler, just put this in your Gemfile:

source :rubygems
gemspec

SEO for Developers: DOs and DON'Ts

2010-11-26T00:00:00+00:00

Normally I’m not one to repost, but I was cleaning my office and came across an old handout from Click Equations and wanted to share it. It’s a good summation of most of what I know about SEO so maybe some others can learn from it too. Hopefully no-one from Click Equations minds, but I’ll be happy make modifications if they do.

DO

Consider the needs of search engines when setting up Web sites and coding pages
Validate HTML, CSS, Links and 508standards before publishing content
Remember that HTML content can be crawled and indexed - but not JavaScript
Use XML Sitemaps to feed to the search engines every URL that you want crawled and indexed
Use Robots.txt to block any files or sub-directories that you do not want the search engines to crawl and index
Ensure that every image has a keyword-relevant filename, Alt Tag, and text description close to where the image is displayed on the page
Use descriptive, keyword-rich URLs for all pages (rather than dynamically-generated alphanumeric URLs)
Make sure that you’re most important pages are linked to in the site’s browsable interface (and with keyword-rich anchor text); the more difficult it is to “find” a page, the less likely it is to rank well
Render in the HTML as much information (i.e., Meta data) as you have about the media files
Include a “Link to this Page” capability as a quick-and-easy means of attracting backlinks from your user community

DON’T

Place heading tags around hyperlinks or snippets of text used on more than one page
Implement URLs that neither a user nor a search engine can understand
Include “stop words” in URLs (and, to, in, etc.)
Have more than one URL resolve to the same page
Let any page return a 404 error; use temporary (302) or permenant (301) redirects depending on whether the original page will [sic]
Hide text to users that you want the engines to see; deliver a consistent experience to both
Use different sub-domains unless your content covers very diverse topic and/or the hosting platform is too inflexible
Use iFrames
Use JavaScript or AJAX extensively; while Google processes some JavaScript, the other engines do not
Do anything solely because of its SEO benefit (think of your users first)

Driving Pure Data with Ruby

2010-11-24T00:00:00+00:00

So I’ve been playing around with Pure Data a lot lately. I’m finally getting to a point where I think I “get” it. But one thing Pure Data doesn’t seem to do very well is sequencing, or building melodies and patterns to play back. Unable to find an open MIDI sequencer for OS X, I turned to Ruby… Full. Double. Rainbow.

First, a little background incase you haven’t played with Pure Data. Pure Data is visual programming language for working with audio signals. A simple sine wave tone at 440Hz would look like this:

To connect that sine wave to a MIDI control you just add a couple boxes:

Of course, you can get a lot more complex. Pure Data has tools for mixing signals, storing data into tables, filtering, manipulating lists of data, etc. There’s also a library called PdMtlAbstractions that has a lot of good tools for handling note off events and ADSR more like a real synth. But even with these tools I was unable to build a sequencer that I was excited to use. Enter Ruby.

Now I’ll probably get this working on MRI soon, but my googling pointed out that there was a MIDI system built into Java. So at the moment this is JRuby only. And turns out that the Java API to trigger notes wasn’t complicated. Here’s a simple scale:

include Java

MidiSystem = javax.sound.midi.MidiSystem
ShortMessage = javax.sound.midi.ShortMessage

# Find the "Bus 1" receiving device
for info in MidiSystem.get_midi_device_info
  if info.get_name == "Bus 1"
    device = MidiSystem.get_midi_device(info)
    break if device.get_max_receivers != 0
  end
end
device.open
receiver = device.get_receiver

# Make a melody
notes = [60, 62, 64, 60] * 2 +
        [64, 65, 67, 67] * 2 + [0]

# Send the notes   
notes.each do |note|
  noteon = ShortMessage.new
  noteon.set_message(ShortMessage::NOTE_ON, 0, note, 127);
  receiver.send(noteon, 0)
  sleep 0.5
end

The first section of the code is just to find the right output device. In this case I have Pure Data configured to listen to “Bus 1” on my IAC Driver. On a Mac you set this up by opening Audio MIDI Setup and pulling up info on the IAC Driver and adding a port. The IAC Driver is basically a virtual MIDI bus that lets you route MIDI signals between software on your computer. For more info on setting that up, check out this tutorial. If you wanted to have this script control a hardware synth, you’d just have to change the name to match what you’re looking for.

The second section just sends some notes. Astute readers may notice that I’m not sending any note off messages. On a proper instrument or synth you’ll need those too, but this simple synth can only play one note, so I’ve left them off for now.

And if you’re curious, here’s what is sounds like.

For my next trick, I’m hoping to build a ruby gem that will help me build songs. I’ve found a few out there, but haven’t been really excited about them yet. Here’s the syntax I have so far.

class Melody < Voice
  def step_down
    notes[0] -= 1
    notes[1] -= 1
  end

  def play_with(&block)
    instance_eval(&block)
    play(4)
  end

  def self.run
    Thread.new do
      v = new(:channel => 1, :notes => %w(G# B C#5 D5))
      3.times do
        v.play_with { step_down }
      end
      v.play_with { step_down; notes[2] -= 1 }
      2.times do
        v.play_with { notes[0] -= 1 }
      end
    end
  end
end

Which sounds like this. Maybe I’ll make something closer to real music with this some day. But for now it’s a lot of fun. Hope you think so too.

UPDATE: The latest version of collavoce has a much nicer syntax for defining voices. Be sure to check out this example for the latest rendition.

Notes From October Philly.rb

2010-10-13T00:00:00+00:00

So usually Trev does notes, but he was presenting, so I tried to take some instead. Here they are, essentially unabridged so excuse any typos. Feel free to comment if you have errata or questions. If you need a little context or want to rate the talk, check out the [SpeakerRate page](http://spkr8.com/e/626 “philly.rb 10/12/2010

SpeakerRate”).

Why VCR? Mocks are hard :) So Trev wrote a big ruby lib with no tests, but didn’t have mocks.

This had lots of HTTP calls. Led to very slow tests. Changing data sets caused lots of breakage.

Twitter example, took 4 seconds to run one test. Also there are a lot of things that can break the test (deleted accounts, etc).

Getting started:

gem install vcr
gem install (fakeweb|webmock) # VCR wraps one or the other

“Cassettes” that record HTTP stuff

To use:

make a vcr_setup.rb, that points to your vcr/cassettes (or other folder) and sets your stubbing lib (fakeweb or webmock).

They are yml, but don’t put them in fixtures in rails 3 or it’ll try to load them like they’re db data.

VCR.use_cassette("mycassettename", :record => :new_episodes) do
 your_test
end

Run it once, and it’s slow. Run it again and it’s fast (case it’ll replay the API responses).

Can pass in :erb => { vars... } to give a context for ERB substitution in the file.

Can also use

VCR.insert_cassette(...) # in before
VCR.eject_cassette #in after

Then you don’t even need the block in the test code. You can also use rspec’s “around” to do use_cassette.

Which http stub lib to use?

FakeWeb is 3 times faster than WebMock, but it only mocks Net::HTTP. WebMock is slower but it works for libcurl’s Patron. Curb coming soon. libwww-perl, etc…

Request Matching By default it’ll match requests on the method and the URI. But you can also match on body/headers if necessary by using :match_requests_on => [:headers, :uri], etc…

You can use different cassettes for the same call to handle edge cases.

Best Practices Set :record => :none in your vcr_setup.rb so that get errors if you make accidental unrecorded HTTP calls.

For ETAGs, putting match => :headers in your config might be a good idea.

Q: what about only doing certain requests to certain services? can you put a per-host filter on it? A: Not sure.

Version 2.0 is gonna have automatic re-recording of cassettes based on date. use_vcr_cassette macro in rspec to do the around stuff for you.

Docs with Maruku, Jekyll and Prawn

2010-09-27T00:00:00+00:00

If you’ve been reading my blog at all you’ve probably noticed that I am not a lawyer. Sadly when starting your own business, there are legal documents involved.

Now I don’t know about you, but doing find and replace on my agreements for every new client sounded tedious and not fun. So I’m working on a way to make it more programmer-ish. Basically I’m taking the Jekyll approach to legal documentation. Markdown with a YAML header goes in, custom-tailored and nicely formatted PDF comes out.

With just under 130 lines of ruby and some help from Maruku, Jekyll and Prawn, I was able to turn this:

---
consultant: Mashion, LLC
client:     Awesome Client
date:       September 23, 2010
---

CONSULTING AGREEMENT
====================

This Consulting Agreement (this “**Agreement**”) is made and entered into
as of {{ date }} (the “**Effective Date**”) by and between {{ client }}
(the “**Company**”), and {{ consultant }} (“**Consultant**”) (each herein
referred to individually as a “**Party**,” or collectively as the
“**Parties**”).

(legalese continues...)

Into this:

Neat, right?

I’ll definitely be releasing the code properly sometime soon. But in the mean time, here’s a gist to whet your appetite. If you have any ideas, or if you’re a lawyer who might want in on this hotness, please do get in touch. Thanks!

Using Runnables in the Redcar Editor

2010-08-12T00:00:00+00:00

So it’s been awhile since I’ve posted, and no I haven’t decided to take up cooking. Although I do use chef a lot at work.

I’ve been spending a lot of time lately working on the Redcar Text Editor. It’s become my favorite way to spend my personal hacking time. My most recent contribution has been some work on “Runnables” which is the Redcar plugin that lets you run commands from inside the editor. Even one of the collaborators on the project didn’t really know how to use it so I thought I’d write an explaination.

Overview

Like I said Runnables lets you run commands inside Redcar. It let’s you set up two types of commands:

Commands: These become list items that you can click on to run. You can view by selecting Project -> Runnables from the menu. They look like this.

File Runners: These are commands that get run when you hit Ctrl+R if your current file matches a regex.

You define these runners in .redcar/runnables/mycommands.json. Runnables will read any *.json file in that directory. The file also gets processed whenever you hit Ctrl+R so you can edit the file runners as much as you like. At the moment, it looks like you have to re-open your project for Commands to get refreshed. I might fix that soon though.

Example

So here’s my features.json file which allows me to run a full test suite as well as use Ctrl+R to run individual Cucumber and RSpec tests:

{
  "commands":[
    {
      "name":        "Full suite",
      "command":     "jruby -S rake",
      "description": "Run the full test suite",
      "type":        "task/ruby/rake"
    }
  ],
  "file_runners":[
    {
      "regex":   ".*\\.feature",
      "name":    "Run as feature",
      "command": "jruby -J-XstartOnFirstThread bin/cucumber __PATH__",
      "type":    "test/ruby/feature"
    },
    {
      "regex":   ".*_spec\\.rb",
      "name":    "Run a spec",
      "command": "jruby -J-XstartOnFirstThread -S spec __PATH__",
      "type":    "test/ruby/spec"
    }
  ]
}

So as you can see, the command is just the command that gets run if the file’s path matches regex and the file path gets substituted for the __PATH__ in the command. I still haven’t really figured out what the type and description fields do for you yet, but I expect I will soon.

Bonus

If you use my color-and-scrolling-runnables branch you’ll also get support for ANSI color output and automatic scrolling (courtesy of Delisa Mason). Hopefully both of these features will be in master soon. Here are the commands to force color if you want to give it a try:

# Force color in Cucumber
jruby -J-XstartOnFirstThread bin/cucumber --color __PATH__

# Force color in RSpec
AUTOTEST=true jruby -J-XstartOnFirstThread -S spec --color __PATH__

Future Enhancements

I’ve been told that this plugin only works on Unix systems right now. So Windows users can’t partake in the awesomeness just yet. I’ll see how I can help there.

I haven’t found a way to make a general *.rb matcher without having my specs run twice. Seems like the plugin needs support for a “last” flag to make sure that we don’t keep moving down the list and running more commands. Perhaps the type field has something to do with it.

I’d like to have a way to reuse the “Run File” tabs that get created so I can just keep re-running my specs without having to clean up old output. I haven’t decided the best workflow for that yet. Sometimes you want to be able to see old output and so I don’t want to just clobber that in all cases.

If you have any other ideas feel free to come chat about it in the Redcar IRC channel or on the Redcar mailing list.

How to mock out jQuery and Raphael

2010-04-29T00:00:00+00:00

Most people are in agreement now that testing is a good thing. But most any JavaScript developer out there will tell you that testing browser-dependent code (jQuery, Raphael, etc.) can be a pain. You usually have to concede to running your tests in the browser, or spend lots time of pounding out env.js bugs to get something headless running.

But here at Hoopla, Trotter and I have found a very happy middle ground. As outlined in his post, it’s trivial to make a simple mock Raphael that satisfies your code and allows you to test what got called. But in practice, maintaining these mock classes gets repetitive quickly.

So I wrote recorderMock.js, which makes it easy to create full-featured mock objects for things like jQuery, Raphael and any other library that doesn’t run outside of the browser.

Say you wanted to test some code that used jQuery to resize a div:

$("#display").width(someComputedWidth).height(someComputedHeight);

I think I just heard your inner tester say “oh shit.” Worry no longer my friend. Building a mock for this with recorderMock is super simple. Just put this in your setup code.

$ = recorderMock("width", "height");

You can even check that they got called with the right values:

expect($.height.__calls[0].arguments).to(eql, [250]);
// or 
expect($.height.__calls.last.arguments).to(eql, [250]);

And specifying return values is only slightly more complicated. Say you want to return mock html for different DOM elements:

this.startDate = $("#start-date").html();
this.endDate   = $("#end-date").html();

Mock it out like this:

$ = recorderMock("html");
$.html.__returns(function(call) {
  var selector = call.previous.arguments[0];
  return { "#start-date": "January 1st, 2010",
           "#end-date":   "January 31st, 2010" }[selector];
});

Need a basic mock of Raphael? Just use this:

Raphael = recorderMock("path", "rect", "text", "attr", "init", "push", "set",
                       "hide", "show", "animate", "animateWith", "rotate",
                       "translate", "setSize");

So there you have it. You can indeed test browser-related code outside a browser. And it’s pretty easy.

recorderMock has a handful of other tricks, and I’ll probably be adding more soon, so keep an eye on the specs for examples on how to use it more fully.

Update 2010-05-06:

I just released version 0.3.0 which includes better support for inspecting the call chain. The above examples have been updated to reflect the API changes and enhancements.

Things I Love About Bundler

2010-04-20T00:00:00+00:00

So I’ve been working with working with Rails 3 and bundler full time for a month and a half now and it’s going swimmingly.

Here are some things that bundler does that I think are awesome.

Gems from git repositories

We use custom forks of arel and savon in our project. Before bundler, managing this would have been a mix of submodules/braid/piston and custom gem files that could easily become a mess. With bundler we just throw this in our Gemfile and we’re done.

gem 'savon', :git => 'git://github.com/hoopla/savon.git'
gem 'arel',  :git => 'git@github.com:hoopla/arel.git'

Gems from the local file system

Much like loading from git, bundler also handles loading gems from a local path. This is great if you want to try out some ideas on a gem, but you’re not yet sure if gem is worth forking.

gem 'mygem', :path => '/path/to/my/gem'

What’s especially awesome is that bundler wires things up so that source modifications get picked up without any sort of repackaging or reinstalling. This beats the pants off of the change source > repackage gem > reinstall gem > test cycle that was so easy to fall into before bundler.

It actually works

I don’t know about you, but I don’t think I’ve ever had a real Rails 2 project on which rake gems:install really worked. There were always a couple of gems (rspec) that you needed to install separately. bundle install on the other hand works pretty much every time.

Now of course it’s not all rainbows and unicorns. Bundler seems to take up some extra startup time beyond what I was used to on Rails 2. And I often wish there were a way to make it check git repositories for updates a little less aggressively. But for 0.9.22, I’m impressed. Hats off to carlhuda, indirect and any others that appear beyond page 3 of the commit log for all their hard work on it.

Managing Unix packages on OS X with Homebrew

2010-03-27T00:00:00+00:00

This month I started a new gig which landed me with a new MacBook so I thought it seemed like a good time to try out the Homebrew package manager. It’s almost a month later and I am loving it. The beer-related jargon doesn’t hurt either.

Have you ever gotten annoyed at the time it takes for a package to get updated on MacPorts or Fink? Or tried to install a MacPorts package only to have it reinstall your ssh client or other core system component? I got fed up with this sort of thing over a year ago and have been compiling packages by hand ever since. Then I found Homebrew.

Installation is straightforward. You’ll need XCode of course, then you can just do this:

sudo chown -R $USER /usr/local
curl -Lsf http://github.com/mxcl/homebrew/tarball/master | tar xvz -C/usr/local --strip 1

Or they have more automated approaches in their README if you’re into that sort of thing.

The real win of Homebrew is how packages are defined: in Ruby. Have a look at this hotness for describing how to install redis:

require 'formula'

class Redis < Formula
  url 'http://redis.googlecode.com/files/redis-1.2.5.tar.gz'
  homepage 'http://code.google.com/p/redis/'
  sha1 'f28d840d8100586796cab02ccd8e91545a92179d'

  def install
    %w( run db/redis log ).each do |path|
      (var+path).mkpath
    end

    ENV.gcc_4_2
    system "make"
    bin.install %w( redis-benchmark redis-cli redis-server )
    
    # Fix up default conf file to match our paths
    inreplace "redis.conf" do |s|
      s.gsub! "/var/run/redis.pid", "#{var}/run/redis.pid"
      s.gsub! "dir ./", "dir #{var}/db/redis/"
    end
    
    etc.install "redis.conf"
  end

  def caveats
    "To start redis: $ redis-server #{etc}/redis.conf"
  end
end

Hot right? What’s more is that if you run brew update it’ll turn your /usr/local into a working git repository where you can tweak these scripts, push to your own fork and contribute back. Compare that to the MacPorts Portfile for redis which took me 5 minutes just to find, let alone tweak or contribute. Homebrew keeps all those files in /usr/local/Library/Formula, so have at it!

For more info on Homebrew check out their wiki or their collection of blog links as I’m sure they’re more accurate than anything I’d produce.

So go grab a beer and toast your package management woes farewell. Hope you enjoy Homebrew as much as I do!

Learning to Draw with Screencasts

2010-02-05T00:00:00+00:00

I’ve been having so much fun with Inkscape lately that I thought I should share. I basically got started with it when my wife and I ended up with no other option for our Christmas cards but to decorate our photos ourselves. Apparently most photo places don’t do Christmas templates in a 4x6 format. So I downloaded Inkscape, bought a set of Christmas-styled stencils from iStockPhoto.com and we went to town.

Then she wanted sparkles. Sparkles… Our stencil set was sadly lacking sparkles. So I did what I always do when I need to learn something: I googled it. And found this lovely tutorial which showed me how to make a sparkle. It worked out great and the Christmas cards looked awesome. I enjoyed the process so much that I subscribed to heathenx’s RSS feed of Inkscape screencasts.

If you’re a coder interested in learning how to create some basic visual elements, I highly recommend checking out screencasters.heathenx.org. It’s basically RailsCasts for vector drawing. So far I’ve only watched the two screencasts, but I feel like I’ve learned a lot already. It also has a similar relaxation appeal to painting happy little trees.

Who knows maybe one day I can even make the jump from engineering to design…

or not.

Migrating from Subversion to ... Subversion?

2010-01-25T00:00:00+00:00

As an update to my previous post, one of my coworkers found that this technique was also applicable to migration between Subversion servers and that using git as intermediary was actually a bit more graceful than the traditional svnadmin dump/load approach. Git wins once again!

The one thing he noted is that this ends up with occasional 0-length patch files, I’m guessing from commits that only modified svn properties. These files will cause git am to abort, but can just be deleted for the re-import.

Here’s the script he used:

#!/bin/sh

# Source URL
SRC_URL="$1"

# Destination URL
DST_URL="$2"

# Source and destination repo types (svn,p4)
SRC_TYPE=svn
DST_TYPE=${SRC_TYPE}

PROJECT=`basename "${SRC_URL}"`

# Clone SRC repo
git ${SRC_TYPE} clone ${SRC_URL} "${PROJECT}_src.git${SRC_TYPE}"

# Julienne SRC clone into patch files
mkdir "${PROJECT}.patches"
cd "${PROJECT}_src.git${SRC_TYPE}"
git format-patch --root HEAD -o "../${PROJECT}.patches"
cd ..

# Clone DST repo with empty target PROJECT dir
svn mkdir "${DST_URL}/${PROJECT}" -m "Initial repository layout."
git ${DST_TYPE} clone "${DST_URL}/${PROJECT}" "${PROJECT}_dst.git${DST_TYPE}"

# Merge SRC patches into DST clone
cd "${PROJECT}_dst.git${DST_TYPE}"
git am "../${PROJECT}.patches/"*

# Commit changes DST repo
git ${DST_TYPE} dcommit --add-author-from
cd ..

Migrating from Perforce to Subversion

2009-11-27T00:00:00+00:00

So my new favorite hack of the week was created while trying to find a good way to import code from our partner’s Perforce repository to our Subversion repository.

I wanted to do this while retaining history but the p4svn script that I found depended on the deprecated Perforce Perl API which made me nervous about trying to get it working.

So instead I decided to use Git as an intermediary. My initial attempts to do this by way of a git merge or rebase didn’t work out. The best I could get was the full source as one commit in subversion. But since git has really solid patch file support, I decided to try using git format-patch and git am to get the changes from one repository to the other.

The end result was about as good as I could have hoped for. Including --add-author-from even put the original Perforce information into the subversion commit logs which was awesome. The only downside I’ve seen so far today is that folders that should be deleted aren’t always deleted in the final import. I’m guessing this has to do with how git ignores empty directories but svn doesn’t. But cleaning them up wasn’t too bad for me since the projects had a consistent structure. If the project had some sort of major reorganization happen, you might want to dig into that and try to figure out a better solution.

So here’s the script, also checked into my randomscripts repository. Feel free to ask any questions or school me on a better way to do this!

#!/bin/sh

# Set these before you start
# export P4PORT=myperforceserver:1666
# export P4USER=myusername
# export P4PASSWD=mypassword

# Source Perforce depot path (without @all)
P4PATH="$1"

# Destination SVN url (without trunk, we create that)
SVNPATH="$2"

PROJECT=`basename "${SVNPATH}"`

# git p4 clone "${P4PATH}@all" "${PROJECT}.gitp4"

mkdir "${PROJECT}.patches"
cd "${PROJECT}.gitp4"
git format-patch --root HEAD -o "../${PROJECT}.patches"
cd ..

svn mkdir --parents "${SVNPATH}/"{trunk,branches,tags} \
          -m "Initial repository layout."
git svn clone "${SVNPATH}/trunk" "${PROJECT}.gitsvn"

cd "${PROJECT}.gitsvn"
git am "../${PROJECT}.patches/"*
git svn dcommit --add-author-from
cd ..

Barcamp Philly, in Japanese

2009-11-26T00:00:00+00:00

A little belated, but not too long ago I went to Barcamp Philly 2009 with my wife and son. It was a great experience not only to be a part of the blossoming Philly tech scene, but also having my family there encouraged me to branch out a little and head to some really enjoyable talks that I probably wouldn’t have otherwise.

Shortly after the event, Kaori posted a writeup in her Mixi blog. I thought this was really cool and wanted to share it with other folks that might be interested. So I’ve reposted it here with her permission.

相方の付き添いでBar campなるものに行って来ました。

IT系やプログラマー系のコンフェランス（協議会？？）みたいな感じかな。

でも堅苦しくなくて、かな～りカジュアル。

大学を貸し切って、いろんな部屋でいろんな人がプレゼンテーションをしてるので、興味があるタイトルならその部屋に行き、自由に聞けたりディスカッション出来るというもの。

テクノロジーにうとい私にはちんぷんかんぷん。。。。と思いきや、意外におもしろい内容のプレゼンテーションもあったり。

カイも参加！

見てておもしろいなと思ったのは、こういうプレゼンテーションとかの途中でも質問とかあったら、みんなどしどし聞いたり、聞いてないのに自分の意見言ったりつっこみ入れたりして積極的なこと。

日本だと、しーーーんとしちゃうよね。

にしても、内容が内容なだけに人々も濃かった。

どれくらいかというと

こんなマニアックなTシャツを着てる人がいるくらい。（何の映画か分かるかな？）

４ヶ月のカイ坊、、、既にこんなところに連れて来られて一体将来どれほどマニアックになるのか。。。。

講義中のカイ。

ちゃんとネーム入りパスをもらった。

Hello, Jekyll.

2009-11-11T00:00:00+00:00

So I just ported my blog from WordPress to Jekyll.

Why? Because once again while posting my latest maven trick I got frustrated trying to post code in my blog and also get the formatting to work the way I wanted it.

I think I just prefer WYSIWYM to WYSIWYG. But that’s just me.

The transition wasn’t bad, but was more manual than I had hoped, mostly because of all the garbage formatting in my WordPress posts. Some were good, but others were a mess due to my own indecision on how to get the article into WordPress (edit in browser, edit as HTML, write markdown then post HTML, etc…).

So we’ll see how this goes. One thing that I really like already is how easy it is to fix broken/deprecated links when your whole blog is just sitting on your file system: Just a simple find and replace. I’m also considering writing a rake task that validates the whole generated site and possibly some sort of job queuing set up to move the widget stuff onto the server and reduce my javascript dependency.

Let me know what you think. There’s still some styling to be done, but I think it’s an improvement over the old site and the lady agrees.

Call JRuby, Jython or other JVM scripting language from Maven

2009-10-23T00:00:00+00:00

Ever been frustrated trying to extend maven? Yeah me too. So here’s a trick I finally pounded out a couple weeks ago that I thought I’d share here.

It’s pretty common place to use the maven antrun plugin to perform some extra build work that you couldn’t otherwise do without writing a full-blown maven plugin. You might even already use it to call scripts that move files around, compress CSS, or whatever. But wouldn’t it be nice if maven could download the script’s runtime for you? It can. Just throw these chunks into the plugins sections of your pom.xml file.

<plugin>
  <artifactId>maven-antrun-plugin</artifactId>
  <dependencies>
    <dependency>
      <groupId>org.jruby</groupId>
      <artifactId>jruby-complete</artifactId>
      <version>1.4.0</version>
    </dependency>
  </dependencies>
  <executions>
    <execution>
      <id>my_script</id>
      <phase>compile</phase>
      <configuration>
        <tasks>
          <java classname="org.jruby.Main" failonerror="yes">
            <arg value="${basedir}/src/main/ruby/myscript.rb" />
          </java>
        </tasks>
      </configuration>
    </execution>
  </executions>
</plugin>

And of course the same technique should work for any language that you can run as an argument java class (jython, rhino, clojure).

Now some of you might be asking “why not use the maven jruby plugin?”. Well because as best I can tell it still runs against JRuby 0.9.9. A bit too far behind the curve if you ask me. I expect you’ll find the same with Jython. So there.

Hope that helps some folks. I know it made wrangling my builds a world easier.

Update (11/13): Thanks to Brian Fox (via irc.codehaus.org#maven) for guiding me toward a much more graceful method of doing this. And for bonus points, the updated method (above) also allows you to load in gems as jar dependencies. Just add them to your dependency list (and maven repository), then require 'rubygems'; require '#{gem_name}' as usual. Hot!

JavaScript templates, build-time lovin'

2009-10-03T00:00:00+00:00

(Reposted from http://github.com/matschaffer/trimpath-templateRegistry)

Ever wanted to render HTML templates from javascript? Yeah, so did we. And so do a lot of people apparently. There are a lot of toolkits around for this.

We at CIM were evaluating some of them and had the realization that since we’re already processing JavaScript (compression) and CSS (from LESS and compression) at build time, why not process the templates at build time as well?

So I give you TrimPath TemplateRegistry. After evaluating all of the above mentioned template toolkits, we settled on TrimPath’s JST because we all could agree that the syntax was reasonable (Pure was a little hit or miss) and it was able to produce fairly clean JavaScript after processing a template. And when I say clean in this case I mean the generated JavaScript also has no dependency on any library. Since we’ve already processed the templates, it’d be a shame if we still required the browser to parse the template toolkit at run time.

It seems to be working so far at least in theory. We haven’t applied this to production code yet, but hopefully we will soon. Check out client/demo.html for a rough sketch of the idea. The “client” folder is what’s intended for use at run-time. The “server” folder is what’s intended for use at build-time.

There’s still a lot of work to be done. My biggest outstanding question is how to handle the the template registration function name such that we can be pretty flexible about how/where the templates get loaded. And of course, we’ll need some specs now that I actually have some rough idea of what the heck I’m doing :)

Harsh opinions on JavaScript testing

2009-08-26T00:00:00+00:00

JavaScript testing has been a hot topic at CIM lately. Enough that I’ve managed to form some opinions on the matter that Arpit thought I should share with the world. So here’s a rundown of all the javascript testing tools I’ve looked at and my opinions on them.

Screw Unit: More than just a funny name, this is so far the most enjoyable javascript testing tool I’ve used yet. BDD looks great in JavaScript. The jQuery-bias also works for us since jQuery is our framework of choice around here. And to top it off, it’s got a beautiful and functional runner which requires almost no boilerplate code allows focused testing with a single click. I wrote the test suite for iSepta Train View in Screw Unit and have been using it at work too.

The biggest downside to Screw Unit is the project momentum. The original authors don’t seem to be doing much with it these days and it’s difficult to find a source of truth. So in the mean time I look to Trotter Cashion’s fork for stability since I know he’s used it for testing a number of production apps. His version also has a better Stubbing/Mocking toolkit than what Screw Unit originally comes with.

If you’re interested in a command line runner Screw Unit on Rails, check out Blue Ridge. Or for off rails (and on Mac), try Screw Driver.

Jasmine: I do have one gripe with Screw Unit that I blame Trotter for (I might not have noticed if he didn’t mention it). It uses snake_casing rather than JavaScript’s own camelCaseConvention. Jasmine gets that right. On top of that, it appears to stay framework and DOM independent. I’m a little concerned about the runner though since they don’t show it off in the readme and the docs recommend find/replace as a method for running focused tests which is super lame.

JsTestDriver: Written by Java developers for Java developers. And as best I can tell offers no support for asynchronous tests. The browser capturing is cool, and I’ve seen some interesting advances in the tooling for this framework, but it doesn’t seem worth the Java culture that comes along for the ride.

JsUnitTest: This is a fork of prototype’s test suite but with the prototype dependency removed. I was excited about this early on, but had a lot of trouble getting it to run correctly across all browsers. The runner pages also require a fair bit of boilerplate which is a big turn-off.

JsUnit: I’ll mention this purely for historical reasons. Don’t use it. It’s old, crufty and I’m pretty sure they spent more time on their logo than they did on the test runner. We started using this on our project originally and quickly grew to hate and ignore it.

JSpec: I haven’t spent much time with JSpec but it does look fairly well thought out so I might give it another chance. What caused me to write it off initially was the introduction of a ruby-like test grammar rather than just straight JavaScript. Helpers for anonymous functions are cool and all but not at the cost of having to learn a new grammar which apparently even has issues running some operations correctly. As much as I love ruby, the JSpec grammar is an unnecessary complication. JavaScript is capable language, use it.

Conclusion: So that’s it. Hope this saves some other people the pain of wading through a number of different testing frameworks. The JavaScript culture is a funny one but I’ve seen a lot of promise and progress lately. If you have any tools you like that I haven’t covered here, please comment!

Installing ImageMagick on OS X Leopard

2009-05-17T00:00:00+00:00

So last night I tried to install ImageMagick on Leopard but couldn’t find the requisite blog article that detailed the installation. So I thought I’d write one. I managed to dig up some forum posts, so here’s the whole deal.

ImageMagick itself compiles fairly easily on OS X, but it’ll end up missing JPEG support, which was kind of a bummer. Here’s how to fix it without using MacPorts (which I avoid these days since it tends to get updated too slowly for a lot of projects).

First get a copy of libjpeg and build it as a shared library:

curl -O http://www.ijg.org/files/jpegsrc.v7.tar.gz
tar -zxf jpegsrc.v7.tar.gz
cd jpeg-7/
ln -s `which glibtool` ./libtool
./configure --enable-shared --prefix=/usr/local
make
sudo make install

Now get a copy of ImageMagick:

curl -O ftp://ftp.imagemagick.org/pub/ImageMagick/ImageMagick.tar.gz
tar -zxf ImageMagick.tar.gz
cd ImageMagick-*/
./configure --prefix=/usr/local
make
sudo make install

Now you should have convert, mogrify, montage or whatever other ImageMagick tools you were interested in. RMagick seems to install just fine after you do this, though I couldn’t get gruff working because of what looks like a dependency on GhostScript. I’ll update this post once I get that worked out.

Update (8/26): Tweaked some of the commands here to account for new versions of libjpeg and ImageMagick. Thanks for the heads up, Amed!

What I learned about Cookies this week

2009-05-09T00:00:00+00:00

A lot of people reading this are probably using frameworks that have decent session storage and don’t often need to worry about cookies. But over at CIM the thought of session state for many tens of millions of requests per day is daunting. As a result we use a lot of cookies. Probably too many, but that’s a story for another day.

Ever read the RFC for cookies? Neither had I. I probably wouldn’t have either until our company decided to standardize on Apache Tomcat for our application containers. What we thought would be an easy conversion turned out to take a few days time because some of our important cookies apparently violate the RFC, but no browser or web server had complained yet. What rules did we break?

The left hand side of a cookie definition can’t contain an ’@’ symbol (along with some others)
The right hand side of a cookie can’t contain ’=’ symbols, so no unescaped key=value pairs

The RFC is a lot to wade through, but thanks to some information from Tomcat’s issue tracker it was made pretty clear. Basically a cookie definition boils down to:


   av-pairs    =     av-pair *(";" av-pair)
   av-pair     =     attr ["=" value]              ; optional value
   attr        =     token
   value       =     token | quoted-string

Where the definition for token and quoted-string are provided in the HTTP/1.1 spec.


    token          = 1*<any CHAR except CTLs or separators>
    separators     = "(" | ")" | "<" | ">" | "@"
                   | "," | ";" | ":" | "\" | <">
                   | "/" | "[" | "]" | "?" | "="
                   | "{" | "}" | SP | HT

    quoted-string  = ( <"> *(qdtext | quoted-pair ) <"> )
    qdtext         = <any TEXT except <">>
    quoted-pair    = "\" CHAR

So there you have it. And most web servers and browsers don’t seem to complain. But if you ever find yourself looking at your server logs or a debugger wondering where you cookies went or why they’re truncated. Then it might be time to double check the RFC.

Oh, and the fix? Well ideally we’ll fix our cookies to comply with the RFC, but that will take some time since we don’t control the creation of all the cookies in question. So the plan for now is to patch Tomcat’s Cookie class to be a bit less strict when it’s parsing the request.

iSepta Train View, my time with Dashcode

2009-03-29T00:00:00+00:00

UPDATE: New version 1.1! Download it here.

UPDATE 2: Github now has issue tracking! So I’m dropping uservoice. If you have ideas, submit them here.

So over the past month I’ve been working with Dashcode trying to come up with a nice representation of Septa train data. I’ve managed to come up with a simple widget that combines the data from iSepta with the ontime/late data available from Septa’s Train View page. So far it seems to be working well. I’ve submitted the widget to Apple downloads and Dashboard Widgets so hopefully you’ll see it show up there soon too. So download your copy and let me know what you think!

As far as working with Dashcode goes, it’s been an interesting experience. I’m still a little lukewarm on it, but it definitely helped with the visual work. I’m not much of a designer, so having Dashcode’s gradient, rounded corner and “glass” effect helpers was perfect for me. It was also nice not having to hand-code the “i” button animation like I did with Digital World Clock.

On the downside of things, I felt like the HTML and javascript generation over-complicated things in some cases. Dashcode provides “Parts” like labels, lists and indicators which are cool but the way you interact with them is a little odd. For example, to add items to a list part you’d do this:

var list = document.getElementById('list').object;
list.setDataArray(trainList);

Which isn’t terrible, but felt like more work than just manipulating a plain old “ul” with jQuery. Granted this specialized interface does also offer streaming-friendly setters, which could be useful for some folks. My bigger gripe is with the labels that get generated like this in the HTML:

<div apple-part="com.apple.Dashcode.part.text" class="apple-text apple-no-children" apple-default-image-visibility="hidden" apple-text-overflow="ellipsis" id="nextTrainLabel" apple-style="part-height-dependent: true;"></div>

Note the lack of contents. They get wired at run time by javascript. My guess is that this makes localization more accessible, but I wonder how many widgets really get localized.

These sort of things made me hesitant to muck around with the HTML and CSS which felt a little limiting when building the widget. But the graphics helpers and quick access to functions like “deploy to dashboard” were definitely nice. And the javascript debugging support felt even more solid than firebug. So all-in-all I’m a happy camper.

One more thing to be careful about if you’re working with Dashcode: when saving your project, Dashcode will regenerate most of the files and directories and blow away files that haven’t been imported into the project. So be careful not to save things under the dcproj bundle or you might lose them. I would bet this applies to .svn folders as well, but all the cool kids are using git nowadays anyway, right?

Removing code is a feature

2009-03-03T00:00:00+00:00

I saw a beautiful thing this evening in the ZenTest 4.0.0 release notes (emphasis mine):

2 minor enhancements:

Deleted autotest/screen - releasing as a separate gem soon.

Deleted test-rails and railstestaudit.

Removing unnecessary code has always given me a warm fuzzy feeling.

In today’s world of backups, version control and dependency management we need to learn to be ruthless with the delete key.

Don’t comment it out. Don’t talk yourself into thinking you’ll use it later. Just delete it.

This is one of the same principals behind the inbox zero concept and it is just as applicable to code. Nice work, ZenTest. We should get you a merit badge.

The Creep of Asynchronicity

2009-02-19T00:00:00+00:00

I’ve been doing a fair bit of JavaScript at work lately and while I really enjoy the language there’s something that’s been nagging at me which I’ve come to call The Creep of Asynchronicity. I’ll use some of the examples I’ve been working with to illustrate the idea.

Let’s start with a function to get all the videos on a device that looks like this:

videos = device.getVideos();
doSomethingWith(videos);

Simple. Pretty much what you would expect in a “device” API, right? But now let’s assume that getVideos() requires a return trip to the web server to get the data. You have two options:

Fly in the face of AJAX, make the call synchronously and lock up your UI.
Change the API to look something like this:

device.getVideos(function(videos) {
  doSomethingWith(videos);
}

Now that’s not so bad, but consider the case where you also need an asynchronous call to get the device object. Now we have:

user.getDevice(function(device) {
  device.getVideos(function(videos) {
    doSomethingWith(videos);
  }
}

Ew… getting kinda nasty there isn’t it? Imagine if we also had to make an asynchronous call to get some details on the videos, and so on.

So the crux of my argument is that without some sort of synchronization mechanism, any introduction of an asynchronous call requires that the whole application become asynchronous to support it. Even just a sleep function would help, but JavaScript has nothing of the sort. The best I’ve come up with so far is recursion, which helps in the event that your asychronous calls are acting upon a list of items uniformly. I used this to load a series of JavaScript libraries like so:

function loadScripts(libraries, callback) {
  if (libraries.length > 0) {
    var lib = libraries.shift();
    jQuery.getScript(lib, function() {
      loadScripts(libraries, callback);
    });
  } else {
    callback();
  }
}

loadScripts(["/user.js", "/device.js"], function() {
  doStuffOnceScriptsHaveLoaded();
});

This could conceivably be used to recurse down a list of asynchronous callbacks (which I did find on the web somewhere but seem to find it at the moment). But I think this might lead to an even nastier looking API.

I’m sure on some level, this just requires a shift in thinking. But there’s a part of me that still longs for that two liner at the top of this post… sigh

Groovy Unit Tests on Maven & Eclipse

2008-12-27T00:00:00+00:00

During our last sprint at work I got a good chance to get Groovy working for our unit tests. It took a bit of googling and trial and error, so hopefully this post will benefit others trying to do the same thing. Here’s what I did:

Set up your pom with the following dependency:

<dependency>
  <groupId>org.codehaus.groovy</groupId>
  <artifactId>groovy-all</artifactId>
  <version>1.6-beta-2</version>
  <scope>test</scope>
</dependency>

And the gmaven plugin under the build section:

<plugin>
  <groupId>org.codehaus.groovy.maven</groupId>
  <artifactId>gmaven-plugin</artifactId>
  <version>1.0-rc-3</version>
  <extensions>true</extensions>
  <executions>
    <execution>
      <goals>
        <goal>testCompile</goal>
      </goals>
      <configuration>
        <sources>
          <fileset>
            <directory>${pom.basedir}/src/test/java</directory>
            <includes>
              <include>**/*.groovy</include>
            </includes>
          </fileset>
        </sources>
      </configuration>
    </execution>
  </executions>
</plugin>

Note that I keep my tests under src/test/java, this avoids needing extra configuration from inside eclipse. src/test/groovy also works, but you’ll need to mark it as a source folder, and it seems to be a little flaky so I stopped that.

At this point you should be able to run your groovy tests with mvn clean install. Or use -Dtest=MyGroovyTest to run a single test.

For eclipse you’ll need the GroovyFeature installed. I currently have version 1.5.6 installed.

Close your eclipse project and rebuild the configuration with mvn eclipse:clean eclipse:eclipse. Open the project back up. You may need to fix the JRE settings for the project in the java build properties. On my machine maven tries to hook the project to a JRE other than the default, compile errors occur, switching back to the default Mac OS JRE resolves that.

Right click on the project root, go to “Groovy -> Add Groovy Nature”. If you use the eclipse maven plugin, don’t turn it on for this project. Enabling maven dependency management doesn’t seem to jive with the eclipse groovy plugin. If I turn it on, I get lots of class not found type errors and have to do eclipse:clean eclipse:eclipse and start over again.

Right click your .groovy test (a class that inherits from groovy.util.GroovyTestCase) and you should have Run As -> JUnit test available. I have my setUp and test methods as void. I used defs originally, but this caused the methods to be ignored.

If you don’t see JUnit available, try cleaning the project. I’ve even turned off the automatic builds and manually ran “Build All” on occasion. Also watch out for compile errors in the groovy files. Eclipse doesn’t reliably warn about it and I’ve seen compilation just silently fail. When in doubt have maven try to run it. Eclipse doesn’t always reliably build the groovy classes, and I often have to clean the compiled classes especially when adding new groovy methods or test functions. I’d say about 75% of the time it just runs.

Dan Schaffer on the groovy mailing list also mentioned noted that refactoring Java classes doesn’t seem to apply to Groovy files. There is a plugin for that, but I haven’t tried it yet.

As usual, feel free to comment if you have any questions about my setup. Hope you find this useful.

GTAC2008 Videos now available

2008-12-12T00:00:00+00:00

Rather than continue my review/rant about GTAC2008, I think I’ll let you just decide for yourself since the videos are now available.

Many of them are less-than-interesting, but the following are probably worth a look.

Boosting Your Testing Productivity with Groovy – Andres Almiray
I’ve been doing a lot of this stuff with Groovy lately, more detail to follow.
- Video: http://www.youtube.com/watch?v=UvWTfVCWKJY
- Slides: http://www.slideshare.net/aalmiray/gtac-boosting-your-testing-productivity-with-groovy/
The New Genomics: Software Development at Petabyte Scale – Matt Wood
It’s not about testing, but it’s a good talk.
- Video: http://www.youtube.com/watch?v=A64WKH9gNI8
- Slides part 1: http://docs.google.com/Presentation?id=dczwht9g_3318qqfb6f5
- Slides part 2: http://docs.google.com/Presentation?id=dczwht9g_393d7zg4xcm
Automated Model-Based Testing of Web Applications – Atif M. Memon and Oluwaseun Akinmade
Nothing here that you can go and download just yet, but very interesting research.
- Video: http://www.youtube.com/watch?v=6LdsIVvxISU
- Slides: http://www.cs.umd.edu/~atif/GTAC08/
Atom Publishing Protocol: Testing your Server Implementation – David Calavera
This gist of this one is really just: check out Ape, it’s cool. But I think David should also be given a lot of credit for giving a pretty solid talk despite it being his first talk in English. Nice work, David!
- Video: http://www.youtube.com/watch?v=uRmWTfT91uQ
- Slides: http://thinkincode.net/gtac_atomPub_testing_your_server_implementation.pdf

The Future of Testing by James A. Whittaker is also probably worth a look, but the video is still listed as “coming soon”, so I’ll link to that when it’s available.

I’ll discontinue my GTAC2008 recap unless anyone is really dying to hear more of my ranting. More blog posts on my Groovy work to follow.

Dude your PubNite was totally epic!

2008-11-18T00:00:00+00:00

I felt a blog post was in order to commemorate a totally epic 2 year anniversary for PhillyOnRails PubNite. We had quite the turnout last night, definitely upwards of 20 people!

Colin took some photos, so I’ll lean on him to get them up on his flickr account soon.

A big thank you to everyone that came out and I’m really looking forward to next month!

My new X-Plat strategy

2008-11-05T00:00:00+00:00

Thanks to a strong collaborative effort between myself and one of the members of our front end team. I’m pleased to announce my new cross-platform strategy for glyph management.

It’s capable of operating under a variety of modes including that of a 6, 9 or lower-case ‘e’. This new initiative will be the focus of my coming year.

(How’s that, Karl?)

GTAC 2008 Recap - Part 2

2008-10-29T00:00:00+00:00

Advances in Automated Software Technologies, Elfriede Dustin and Marcus Borch

This started with focus on applying hardware testing techniques to software testing. Namely with regards to reusable components (citing koders.com and krugle.com). The components in question seemed to largely be toolkits that they use in testing including

STAX/STAF
Fire eye – for test data generation
VNC Robot – for noninvasive testing
logwatch, LoFiMo – for log monitoring
Rich client platform (in Eclipse) – for test management

Beyond the tools mentioned, the bulk of the presentation on a system that they built for generating junit test cases for either C++ or Java logic from excel sheets (the logic translation was done with ANTLR). The test spreadsheet was pounded into XML then into Java then run as tests. When asked why they don’t just interpret the spreadsheet directly they gave an answer regarding the DoD’s requirements for transparency. The whole thing seemed horribly static to me, but I suppose if your client is our government you probably have to jump through a variety of hoops.

Boosting Your Testing Productivity with Groovy, Andres Almiray

This talk presented a few things about Groovy that I hadn’t heard yet. First that Groovy supports TestNG out of the box, and also that most Java code can run in the Groovy interpreter without modification. The only java construct which Groovy doesn’t support is inner classes (I’m guessing cause they look like closures).

Andres showed a number of the tricks Groovy is capable of such as closures, mocking and stubbing. It seemed pretty useful that Groovy can also stub existing Java classes and also can masquerade simple hashes as java objects, providing a pretty flexible mocking situation. The syntax was something like:

def proxyString = [
  startsWith: { -> return true }
] as String

The proxyString object will now pass for a String so long as you don’t try to call any methods other than startsWith.

According to Andres, this can also all be dropped into an existing JUnit or TestNG infrastructure by means of eclipse and maven plugins. So I’m thinking my next free-time project might be to rewrite some of comcast.net’s unit tests in Groovy to see just how well it will blend. He also discussed using Groovy with DbUnit for testing databases as well as using it with Easyb for behavior driven development. And also one of participants brought up Tellurium, which apparently uses Groovy to drive selenium.

This was definitely the best overall talk so far. I still don’t think I could support Groovy over Ruby for general purpose development, but it seems to have a solid home for testing Java applications. I look forward to trying this out on my work projects in the next week or two.

Lunch talks

Google made the smart move of providing lunch at the conference so we could all stay together. I sat with developers from a number of different companies and picked up on some cool technologies like ModelJUnit and also got a demo of a unit test correlation webapp that Todd Wells was working on. I even got an introduction to the micro-finance site, Kiva which I could definitely see throwing some money at.

I hope you’re enjoying my GTAC 2008 overview so far. I expect it will take about 3-4 more posts to get it all up here. Feel free to comment if you’d like to see more or less of my own personal commentary, or for any other reason.

GTAC 2008 Restrospective

2008-10-26T00:00:00+00:00

I traveled to Seattle last week for this year’s Google Testing and Automation Conference. I tried to take some notes for the benefit of my own memory and others, so I’ll be posting notes and reactions to my blog over the next few days starting with this post.

As for a quick overview of this year’s conference, here it is: the attendees were great, but many of the presentations were really weak.

The videos from previous conferences had me really excited for this conference, but about half of this year’s presentations were pretty lame. And the final presentation was outright appalling. So much so that I’m still having a hard time letting go of my frustration about it, but more on that later.

I have no way to know just what went wrong, but I really hope Google can learn from these talks and try to come up with a better offering next year. Or perhaps we can all learn from this and step up to the plate with our own presentations for next year. Either way, I’m still glad I went. I just wish I had spent more time outside the presentation hall. So without further rant, here’s my review of the first talk:

The Future of Testing, James A Whittaker

James opened the conference with a strong message about the magic that software makes possible in the world, including references to the search for earth-like planets and understanding autism. He then showed us a somewhat cheesy video of Microsoft’s vision for the future of software and followed it up with the very real prospect of “but how will we test it?” He then outlined his vision for the future of testing which was drawn from some of his previous blogs entries.

The first part he presented was a vision of thousands of virtualized environments and bundled tests such that tests for a given domain and be purchased along with the environments to run them on. I mostly agreed with the idea, but couldn’t help but wonder: Should environmental software bugs really be addressed with a brute-force testing effort across all possible environments? Or should we work in reducing the number of environments that can effect software through proper encapsulation. Linux and Unix systems reduce the number of environments by limiting communication between components such that crashes generally only effect one corner of the total system. Apple reduces the number of environments by only supporting a handful of custom hardware. I’m sure the right answer varies depending on the situation, but I doubt tens of thousands of commodity virtual machines will really cut it.

Mr. Whittaker’s second point was visualization. In most other forms of engineering you can clearly look at the components that make up a system. But even fairly simple software systems are too complex to easily visualize. He proposed that we focus more on visualizing software for the purposes of testing and showed one of the tools that he had used at Microsoft. I can’t find a link to this tool anywhere but basically it showed a tree map of the Windows components with size indicating the size of the component and color intensity indicating code complexity. If anyone has any ideas where I can find a freely available version of this tool, please let me know cause it looked pretty cool. He mentioned that one of the ISSRE 2008 chairs had worked on it, but I can’t figure out which one just yet. I might just have to talk to Arpit on this one a bit since I’m sure it wouldn’t be too hard for him to come up with such a visualization given his previous experience in tree maps.

So that’s one down and about 12 to go. Stay tuned coverage on the rest of the talks and I’ll also let you know as soon as I see that the videos are available from google.

Fork my bash profile

2008-10-02T00:00:00+00:00

Some of you may remember my tumblr post about using a directory of configuration files in place of the standard single .profile script for setting up a Unix environment. I’ve since refined the idea even more and started working on generalizing it for use across multiple operating systems. And to make it even more fun I’ve started publishing it to github.

I have a number of tricks in there like tab-completion for both ssh hosts and rake tasks, and prompts that react to error conditions. If you’re interested just clone my repository as ~/.profile.d and link it like you see in this gist:

mv ~/.profile ~/.profile.old
git clone git://github.com/matschaffer/profile.git ~/.profile.d
ln -s ~/.profile.d/init ~/.profile

Or if you have some of your own ideas, just fork my project and have fun! The url for the repository browser is: http://github.com/matschaffer/profile/tree/master

Let me know what you think. I’d love to incorporate other tricks that people might have.

More work on Corundum

2008-09-09T00:00:00+00:00

So last night I did a little more work on Corundum (still not totally satisfied with the name). I managed to get most of the pom stuff and JRuby dependency packaged. Now any project that uses it just needs this simple pom file and this assembly file. The assembly file is still a thorn in my side and hopefully I can figure out how to get it out of there. I’m planning to look at the flex-mojos project to see how they implement the swc packaging, maybe there’s an answer there.

I feel like this exercise has taught me just how inextensible maven really is. Maybe I’m doing it wrong but packaging this experiment for distribution has resulted in 2 sub-projects: one to set up the dependencies and assembly plugin and another to package the jruby runner class. And now I fear to think what it will take to release this. I might have to try doing something similar with rake or buildr as well just for comparison’s sake.

An experiment with Maven and JRuby

2008-08-30T00:00:00+00:00

So in following with my last JRuby post, this weekend I came up with the next piece to the puzzle; how to use maven to build a self-contained jar file that runs ruby scripts. It’s still pretty raw and lacking an interesting name, but I threw my test code up on github for now to assist in its evolution. If you’re interested in trying it out do the following:

git clone git://github.com/matschaffer/corundum.git
cd corundum/
mvn clean install
cd testapp/
mvn clean install
java -jar target/testapp-0.0.1-SNAPSHOT-jruby-complete.jar

With luck, I’ll have this abstracted somehow so you don’t have to really invade your project, but rather can just include an appropriate pom.xml and be on your way. Maybe some of the friendly folks in #maven can help me out. And once it’s more polished, expect a release on code.cimians.com.

Consider this one more step in my plan to subvert the java-centric development world. And now I’ll be accompanied by a small army of ruby scripts wearing jar-file disguises.

Automatic iSync

2008-07-26T00:00:00+00:00

I got this from hohle, but the formatting on Jon’s post is less-than-ideal. So here it is, reposted for easy copy/paste:

Download his applescript here.

And here’s the plist:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN"
 "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>Disabled</key>
    <false/>
    <key>Label</key>
    <string>local.isync.sync</string>
    <key>LowPriorityIO</key>
    <true/>
    <key>Nice</key>
    <integer>1</integer>
    <key>ProgramArguments</key>
    <array>
        <string>osascript</string>
        <string>
          /Users/schapht/Library/Scripts/AutoSync.scpt
        </string>
    </array>
    <key>StandardErrorPath</key>
    <string>/dev/null</string>
    <key>StandardOutPath</key>
    <string>/dev/null</string>
    <key>StartInterval</key>
    <integer>1800</integer>
</dict>
</plist>

Just make sure to change your plist to point to wherever you keep AuthSync.scpt. Then save it to ~/Library/LaunchAgents/local.isync.sync.plist and run the following from your Terminal:

launchctl load ~/Library/LaunchAgents/local.isync.sync.plist
launchctl start local.isync.sync

BerkelyDB Java Edition in JRuby

2008-07-20T00:00:00+00:00

At work I’ve recently been tasked with figuring out how to backup and rename databases in the Berkeley DB store that’s in one of our middleware components. So I thought I’d try it out in JRuby. Getting the basics was surprisingly easy:

module J
  require 'java'
  require 'je-3.2.44.jar'
  import 'com.sleepycat.je.Environment'
  import 'com.sleepycat.je.EnvironmentConfig'
end

conf = J::EnvironmentConfig.new
env = J::Environment.new(java.io.File.new('/opt/data/bdb'),
                         conf)

if ARGV.length == 2
  env.get_database_names.each do |name|
    env.rename_database(nil, name, name.gsub(ARGV[0], ARGV[1]))
  end
end

puts env.get_database_names
env.close

There are a few gotchas to be aware of. First keeping all your java includes in a module seems to be the best approach. I got somewhat flakey behavior when trying to do those import statements in the global scope. And second, don’t try to include java.io.File. It causes warnings about redefining File. I’m guessing because it has the same name as the ruby File class.

Next I had to make a standalone jar file so that our operations team could run it without installing JRuby. Sadly, this is not so easy. Rawr will allow you to package your ruby script into a jar, but the resulting jar doesn’t contain JRuby or any other jar dependencies. There’s also the rubyscript maven plugin, but that only stores ruby scripts into your system as maven mojos.

Neither of these solutions really fit, so I decided to just code it in java for now. For java projects, maven makes creating the standalone jar easy, as shown here. I’m thinking that between some of Rawr’s work and maven’s assembly plugin there’s a perfect solution. But I’ll have to do a bit more hacking to find it.

Mat Schaffer's blog

Monitoring my home internet with Elastic

The approach

Internet Speed Logger

Using the Elastic Stack

Setting up the cluster

Setting up the Ookla CLI

Setting up filebeat

Graphing

Results and Conclusion

Dealing with MacBook CPU throttling

Uninstalling Docker Desktop for macOS

The basics

Running docker compose

What about kubernetes?

Wrap up

A Startup Weekend retrospective

Things that worked

Things that didn’t work so well

Wrap up

First look at Otto and Nomad

The big one, Otto

A few surprises

The takeaway

Also, Nomad

What should I monitor?

The basics

Deeper errors

Tracking performance

OS & Runtime level metrics - the USE method

Next steps - tooling

Statsd -> Graphite

Zabbix

MRTG

Atlas from Netflix

Conclusion

It's war out there. Get yourself a sub.

Rethinking My Kanban Board

Thoughts on Scalability

Backward compatibility on all fronts

Runtime controls

App-level focus

Auto-scale everything

Rebooting

I taught Rails at UPenn

I took a full-time job at Netflix

I moved to San Jose

I rebooted this blog

Mashion's Pairing Rig

A paragraph on sexism in computer science

Run CI locally on Jenkins

Creating a minimal Ubuntu VirtualBox image

Running CloudFoundry with VirtualBox on OS X

How to hire a Rails developer

1. Get involved

2. Be a Presenter or a Sponsor

3. Don’t talk about your degree

4. Have a business plan

5. Don’t hire a “Rails” developer

Net::HTTP Mocking during Cucumber Tests

Making your own Ruby gem

SEO for Developers: DOs and DON'Ts

DO

DON’T

Driving Pure Data with Ruby

Notes From October Philly.rb

Docs with Maruku, Jekyll and Prawn

Using Runnables in the Redcar Editor

Overview

Example

Bonus

Future Enhancements

How to mock out jQuery and Raphael

Things I Love About Bundler

Gems from git repositories

Gems from the local file system

It actually works

Managing Unix packages on OS X with Homebrew

Learning to Draw with Screencasts

Migrating from Subversion to ... Subversion?