Julio Capote's Blog - Feed

The first thing I've been adding to AGENTS.md

2026-06-01T00:27:17Z

The first thing I’ve been adding to AGENTS.md

My projects these days will usually begin with an AGENTS.md file where I’ll define the stack of linters and context required for an agent to successfully stumble onto a working solution (most of the time, anyway).

But lately, I’ve been starting with just the following snippet:

## RFCs

Significant changes, architectural decisions, and new features should be proposed as RFCs in the `rfcs/` directory. RFCs use the format `rfcs/YYYY-MM-DD_short_title.md` with the following structure:

- `# Title` — short descriptive title
- `**Date:**` — proposal date (ISO format)
- `**Status:**` — `Proposed`, `Accepted`, `Implemented`, or `Rejected`
- `## Goal` — what the RFC aims to accomplish
- Remaining sections are free-form but typically include motivation, technical details, migration notes, and an implementation checklist
- When moving an RFC to `Implemented`, update `AGENTS.md` and `README.md` to reflect any new infrastructure, commands, or workflows introduced by the RFC

Then in a fresh session I’ll prompt:

“Let’s create a new RFC to insert goal here. Ask me any questions to disambiguate the plan”

(I’d imagine grill-me would work well here too).

After some back and fourth we have a Proposed RFC pushed up as a Pull Request.

What I like about pushing up just the RFC is that we can discuss/socialize the plan before costly time and tokens are spent pursuing a non-obvious architectural dead-end. This is exactly how the real RFC process works.

Another benefit is once the RFC is moved to Implemented, the RFC stays within the repository forever, effectively turning them into a free Architecture Decision Record (this is why the date in the filename matters).

I’ve already noticed my agents save research time (and tokens) while also avoiding repeat design mistakes by leveraging previously Implemented RFCs.

Running an aarch64 Fedora VM on MacOS using QEMU 10

2025-09-06T18:47:34Z

Running an aarch64 Fedora VM on MacOS using QEMU 10

“Works on my machine”

The following configuration works on my 2021 M1 Max laptop running MacOS Sequoia 15.6.1.

ARM Architecture

Most of the guides I found were focused on emulating amd64/x86-64 architectures. This guide instead targets the aarch64/arm64 architecture (same as the host system) to minimize emulation overhead.

Steps

These steps should get you a Fedora Server VM that you can SSH into from your host OS.

Install QEMU

$ brew install qemu

Download Fedora Server filesystem image

Thankfully, Fedora provides ready-to-go filesystem images on their downloads page. Download the QEMU qcow2 filesystem image for the latest server version (42 as of writing).

Resize the Fedora Server filesystem image

The Fedora Server image downloaded in the previous step is only large enough to fit the base installation and will likely need to be resized for your needs. You can use qemu-img to resize it like so:

$ qemu-img resize Fedora-Server-Guest-Generic-42-1.1.aarch64.qcow2 15G

Where 15G is the target size.

Create a startup script `start.sh`

Create a file start.sh that will contain the qemu invocation for your new VM.

I found it helpful to check this script into git while iterating on different qemu arguments so I could rollback to working versions.

The script:

qemu-system-aarch64 \
    -name "Fedora" \
    -machine type=virt,iommu=smmuv3 \
    -accel hvf \
    -cpu cortex-a57 \
    -smp 4 \
    -m 2048 \
    -rtc base=utc \
    -drive if=pflash,format=raw,file="/opt/homebrew/share/qemu/edk2-aarch64-code.fd",readonly=on \
    -drive if=pflash,format=raw,file="/opt/homebrew/share/qemu/edk2-arm-vars.fd" \
    -drive file="Fedora-Server-Guest-Generic-42-1.1.aarch64.qcow2",if=virtio,format=qcow2 \
    -boot menu=on \
    -display default \
    -device virtio-gpu \
    -nic user,id=NAT,model=virtio-net-pci,mac=02:00:00:00:00:01,hostfwd=tcp::2222-:22 \
    -device qemu-xhci \
    -device usb-kbd \
    -device usb-tablet

Argument Explanation

Some of these arguments are worth paying attention to, I’ll list the important ones below.

accel hvf: This sets the acceleration framework to the use native MacOS Hypervisor Framework.
m 2048: Give the VM 2GB of RAM.
smp 4: Give the VM 4 CPUs.
-nic user,id=NAT,model=virtio-net-pci,mac=02:00:00:00:00:01,hostfwd=tcp::2222-:22: The hostfwd option forwards port 2222 on the host OS to port 22 (ssh) on the guest OS.

Start the VM

Boot up the VM using start.sh

$ sh start.sh

You should see a window open up like so:

Then you’ll see it say “Display output is not active.”, this is okay, just wait a bit, eventually you will see the machine boot.

Configure Fedora Server

The first time you boot Fedora Server there is a clunky setup text UI thing for setting up a non-root user and giving it a password. Once this is done and you can hit c to continue, your VM is good to go.

SSH from Host OS

You should now be able to SSH into the Guest OS using the username and password created in the previous step by using port 2222, like so:

$ ssh capotej@localhost -P 2222

Grow Guest filesystem to use new size

In order for the Guest OS to take advantage of new size from the qemu-resize above, we need to grow the root partition as well as extend our logical volume using the commands below.

Extend the partition

$ sudo growpart /dev/vda 3

Extend the physical volume

$ sudo pvresize /dev/vda3

Extend the logical volume

$ sudo lvextend -l +100%FREE /dev/systemVG/LVRoot

Resize the filesystem

$ sudo xfs_growfs /

Verify extra space

You can verify that / has more space by running df like so

$ df -h /

Shutting down the VM

You can use the standard shutdown command to shutdown the VM while logged into ssh:

$ sudo shutdown -h now

Headless Mode

Once you have your VM setup, you can edit start.sh and change display to :

-display none -serial null \

Then when you run start.sh it will run the VM in the foreground without a display. You can use Ctrl-C to stop the VM from the host OS.

Your VM should now be ready for experimentation, happy VMing!

Tmux Session Coloring

2014-02-24T00:00:00Z

Tmux Session Coloring

Recently, I’ve really gotten into tmux for managing all my terminal sessions/windows. Not so much for the panes, but more for keeping a highly contextual environment per project or task.

As the number of sessions grew, they became difficult to tell apart. For a few days now, I’ve had the idea of hashing the name of the session into a unique color, so that every session had its own status-bg color.

First, the tmuxHashColor function:

tmuxHashColor() {
  local hsh=$(echo $1 | cksum | cut -d ' ' -f 1)
  local num=$(expr $hsh % 255)
  echo "colour$num"
}

In our ns function (new session), we hash the supplied session name to a color, then use tmux send-keys to set its status-bg color to it:

ns() {
  if [ -z $1 ]; then
    1=$(basename $(pwd))
  fi
  tmux new-session -d -s $1
  local color=$(tmuxHashColor $1)
  tmux send-keys -t $1 "tmux set-option status-bg $color" C-m
  tmux send-keys -t $1 "clear" C-m
  tmux attach -t $1
}

Now every session has it’s own distinct status-bg color!

Golang HTTP Handlers as Middleware

2013-10-07T08:52:00Z

Golang HTTP Handlers as Middleware

Most modern web stacks allow the “filtering” of requests via stackable/composable middleware, allowing you to cleanly separate cross-cutting concerns from your web application. This weekend I needed to hook into go’s http.FileServer and was pleasantly surprised how easy it was to do.

Let’s start with a basic file server for /tmp:

go main.go
func main() {
    http.ListenAndServe(":8080", http.FileServer(http.Dir("/tmp")))
}

This starts up a local file server at :8080. How can we hook into this so we can run some code before file requests are served? Let’s look at the method signature for http.ListenAndServe:

func ListenAndServe(addr string, handler Handler) error

So it looks like http.FileServer returns a Handler that knows how to serve files given a root directory. Now let’s look at the Handler interface:

type Handler interface {
    ServeHTTP(ResponseWriter, *Request)
}

Because of go’s granular interfaces, any object can be a Handler so long as it implements ServeHTTP. It seems all we need to do is construct our own Handler that wraps http.FileServer’s handler. There’s a built in helper for turning ordinary functions into handlers called http.HandlerFunc:

type HandlerFunc func(ResponseWriter, *Request)

Then we just wrap http.FileServer like so:

func OurLoggingHandler(h http.Handler) http.Handler {
  return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
    fmt.Println(*r.URL)
    h.ServeHTTP(w, r)
  })
}

func main() {
    fileHandler := http.FileServer(http.Dir("/tmp"))
    wrappedHandler := OurLoggingHandler(fileHandler)
    http.ListenAndServe(":8080", wrappedHandler)
}

Go has a bunch of other builtin handlers like TimeoutHandler and RedirectHandler that can be mixed and matched the same way.

Playing with groupcache

2013-07-28T14:49:00Z

Playing with groupcache

This week, @bradfitz (of memcached fame) released groupcache at OSCON 2013. I’m already a big fan of memcached and camlistore, so I couldn’t wait to download it and kick the tires.

By the way, I strongly recommend you go through the slides and README before going further.

What groupcache is not

After downloading it (without reading the slides), I instinctively searched around for how to actually start the server(s), only to find nothing. Turns out, groupcache is more of a library with a server built in, rather than a traditional standalone server. Another important consideration is that theres no support for set/update/evict operations, all you get is GET. Really fast, consistent, distributed GET’s.

What it is

Once you realize that groupcache is more of a smart, distributed LRU cache, rather than an outright memcached replacement, it all makes much more sense. Especially considering what it was built for, caching immutable file blobs for dl.google.com.

How to use it

For groupcache to work, you have to give it a closure in which: given a key, fill up this dest buffer with the bytes for the value of that key, from however you store them. This could be hitting a database, a network filesystem, anything. Then you create a groupcache group object, which knows the addresses of all the other groupcache instances. This is pluggable, so you can imagine rigging that up to zookeeper or the like for automatic node discovery. Finally, you start groupcache up by using go’s built in net/http and a ServeHTP provided by the previously constructed group object.

Running the demo

In order to really try out groupcache, I realized I needed to create a mini test infrastructure, consisting of a slow database, frontends, and a client. Visit the Github Repo for more details. This is what the topology looks like:

Setup

git clone git@github.com:capotej/groupcache-db-experiment.git
cd groupcache-db-experiment
sh build.sh

Start database server

cd dbserver && ./dbserver

Start Multiple Frontends

cd frontend
./frontend -port 8001
./frontend -port 8002
./frontend -port 8003

Use the CLI to play around

Let’s set a value into the database:

./cli -set -key foo -value bar

Now get it out again to make sure it’s there:

./cli -get -key foo

You should see bar as the response, after about a noticeable, 300ms lag.

Let’s ask for the same value, via cache this time:

./cli -cget -key foo

You should see on one of the frontend’s output, the key foo was requested, and in turn requested from the database. Let’s get it again:

./cli -cget -key foo

You should have gotten this value instantly, as it was served from groupcache.

Here’s where things get interesting; Request that same key from a different frontend:

./cli -port 9002 -cget -key foo

You should still see bar come back instantly, even though this particular groupcache node did not have this value. This is because groupcache knew that 9001 had this key, went to that node to fetch it, then cached it itself. This is groupcache’s killer feature, as it avoids the common thundering herd issue associated with losing cache nodes.

Node failure

Let’s simulate single node failure, find the “owner” of key foo (this is going to be the frontend that said “asking for foo from dbserver”), and kill it with Ctrl+C. Request the value again:

./cli -cget -key foo

It’ll most likely hit the dbserver again (unless that particular frontend happens to have it), and cache the result on one of the other remaining frontends. As more clients ask for this value, it’ll spread through the caches organically. When that server comes back up, it’ll start receiving other keys to share, and so on. The fan out is explained in more detail on this slide.

Conclusion / Use cases

Since there is no support (by design) for eviction or updates, groupcache is a really good fit with read heavy, immutable content. Some use cases:

Someone like Github using it to cache blobrefs from their file servers
Large websites using it as a CDN (provided their assets were unique logo-0492830483.png)
Backend for Content-addressable storage

Definitely a clever tool to have in the distributed systems toolbox.

Shout out to professors @jmhodges and @mrb_bk for proof reading this project and post

Automatic High Quality Releases

2012-11-13T21:31:00Z

Automatic High Quality Releases

Recently, I invested some time into automating some of the work that goes into a Finatra release.

The work consists of updating:

The version in the XML fragment of the main README.markdown
The version in the pom.xml of the example app
Any API changes in the example app
The version in the template pom.xml of the app generator
The generated unit test of the app generator that demonstrates testing any new API features
Any API changes inside the app template of the app generator

Using sub, I was able to create a finatra command that automated all of the above based on a single template, which also happens to be the main unit test. This ensures that the README, the example app, and the app generator never fall out of sync with the frameworks API.

Last week we released 1.1.0, and the README was completely generated, as was the example app. Not to mention, all generated apps would also contain the latest templates and examples!

Let’s dive into how it all works:

The source of truth

I annotated our main unit test with special tokens, like so:

```scala ExampleAppSpec.scala class ExampleSpec extends SpecHelper {

/* ###BEGIN_APP### */

class ExampleApp extends Controller {

/**
 * Basic Example
 *
 * curl http://localhost:7070/hello => "hello world"
 */
get("/") { request =>
  render.plain("hello world").toFuture
}

}

val app = new ExampleApp

/* ###END_APP### */

/* ###BEGIN_SPEC### */

“GET /hello” should “respond with hello world” in { get(“/”) response.body should equal (“hello world”) }

/* ###END_SPEC### */ } ```

Using the special /* ### */ comments, the main app and its test can be extracted from the code of our test.

The app generator

Now that we have our “template”, we can build our app generator to use it. I customized base and ended up with: script/finatra/libexec/finatra-new

You can then run:

$ ./finatra new com.example.myapp

and it will generate myapp/ based on the tested example code from the test suite above.

The example app

The example app is just a generated app using the latest app generator:

#!/bin/bash
# Usage: finatra update-example
# Summary: generates the example app from the template

set -e

source $_FINATRA_ROOT/lib/base.sh

tmpdir=$(mktemp -d /tmp/finatra_example.XXX)

$_FINATRA_ROOT/bin/finatra new com.twitter.finatra_example $tmpdir

cp -Rv $tmpdir/finatra_example/ $EXAMPLE_REPO

rm -rf $tmpdir

cd $EXAMPLE_REPO && mvn test

This also tests the app generator and the generated app!

Updating the README

Lastly, there’s a command for updating the README with the new example and version number.

Announcing Finatra 1.0.0

2012-11-07T21:20:00Z

Announcing Finatra 1.0.0

After months of work Finatra 1.0.0 is finally available! Finatra is a scala web framework inspired by Sinatra built on top of Finagle.

The API

The API looks like what you’d expect, here’s a simple endpoint that uses route parameters:

get("/user/:username") { request =>
  val username = request.routeParams.getOrElse("username", "default_user")
  render.plain("hello " + username).toFuture
}

The toFuture call means that the response is actually a Future, a powerful concurrency abstraction worth checking out.

Testing it is just as easy:

"GET /user/foo" should "responds with hello foo" in {
  get("/user/foo")
  response.body should equal ("hello foo")
}

A super quick demo

$ git clone https://github.com/capotej/finatra.git
$ cd finatra
$ ./finatra new com.example.myapp /tmp

Now you have an /tmp/myapp you can use:

$ cd /tmp/myapp
$ mvn scala:run

A simple app should’ve started up locally on port 7070, verify with:

$ curl http://localhost:7070
hello world

You can see the rest of the endpoints at /tmp/myapp/src/main/scala/com/example/myapp/App.scala

Heroku integration

The generated apps work in heroku out of the box:

$ heroku create
$ git init
$ git add .
$ git commit -am 'stuff'
$ git push heroku master

Make sure to see the full details in the README and check out the example app.

Props to @twoism and @thisisfranklin for their code, feedback and moral support.

Base: A Scala Project Generator

2012-11-01T14:39:00Z

Base: A Scala Project Generator

Finally got tired of copy pasting other projects and gutting them to make new ones, so I created base, a shell command that creates new scala projects.

Creating the project:

$ base new com.capotej.newproj
creating project: newproj
  creating App.scala
  creating AppSpec.scala
  creating pom.xml
  creating .gitignore
  creating .travis.yml
  creating LICENSE
  creating README.markdown
Done! run mvn scala:run to run your project

Based on the package name, it inferred that the project name is newproj and created the project under that folder. Let’s build and run it:

$ cd newproj
$ mvn compile scala:run
(... maven output ...)
hello world

This uses the new incremental compiler for maven, zinc, which dramatically speeds up compile times (except for the first time you run it). It also sets you up with the latest scalatest maven plugin, which gives you sweet looking test output, like so:

See the base README for installation instructions.

Riak at Posterous

2012-10-11T13:47:00Z

Riak at Posterous

A few months ago, I gave a presentation on how Posterous uses Riak for it’s post cache; At #ricon2012 I ended up retelling this story to numerous people, so I thought I’d post the slides and video here.

An Embedded Key/Value Store for Shell Scripts

2012-10-07T10:06:00Z

An Embedded Key/Value Store for Shell Scripts

UPDATE: this is now available as a sub command, here: kiev

Cooked this up last night when I needed a simple key/value store for use in a shell script:

#!/bin/sh

DBFILE=example.db

put(){
  echo "export kv_$1=$2" >> $DBFILE
}

del(){
  echo "unset kv_$1" >> $DBFILE
}

get(){
  source $DBFILE
  eval r=\$$(echo "kv_$1")
  echo $r
}

list(){
  source $DBFILE
  for i in $(env | grep "kv_" | cut -d= -f1 ); do
    eval r=\$$i; echo $(echo $i | sed -e 's/kv_//') $r;
  done
}

## cmd dispatch

if [ ${1:-0} == "set" ]; then
  put $2 $3
elif [ ${1:-0} == "get" ] ; then
  get $2
elif [ ${1:-0} == "list" ] ; then
  list
elif [ ${1:-0} == "del" ] ; then
  del $2
else
  echo "unknown cmd"
fi

Use it like so:

$ ./db.sh set foo bar

$ ./db.sh get foo

$ ./db.sh set foo baz

$ ./db.sh get foo

$ ./db.sh del foo

$ ./db.sh list

How it works

Every time you update/set/delete a value, it writes a shell expression to an append-only log, exporting a shell variable (key) with that value. By sourcing the file every time we read a value, we replay the log, bringing our environment to a consistent state. Then, reading the value is just looking up that dynamic variable (key) in our shell environment.

Finagle with scala-bootstrapper

2012-01-25T09:45:00Z

Finagle with scala-bootstrapper

I’ve been fascinated by the concepts in finagle for some time, but being a scala noob, I never knew how to bootstrap a finagle project. Turns out twitter has a gem, scala-bootstrapper, that generates a simple thirft based key/value store for you. There’s even atutorial on how to extend the example project into a distributed search service.

This is a guide on setting it all up locally, it assumes you have Git, Homebrew, and OS X.

Install scala 2.8.1

$ brew versions scala
$ cd/usr/local/(or wherever you have homebrew installed)
$ git checkout -b scala281 0e16b9d(make sure the SHA matches versions output)
$ brew install scala
$ git checkout master$git branch -D scala281

Install sbt 0.7.4 (assumes you have a ~/bin in your $PATH)

$ curl -O http://simple-build-tool.googlecode.com/files/sbt-launch-0.7.4.jar > ~/bin/sbt-launch.jar
$ echo 'java -Xmx1G -jar `dirname $0`/sbt-launch.jar "$@"'> ~/bin/sbt

Install scala-bootstrapper

$ gem install scala-bootstrapper

Generate finagle project**

$ mkdir newbird
$ cd newbird
$ scala-bootstrapper newbird
$ sbt update
$ sbt test

Add a Client class

create newbird/src/main/scala/com/twitter/newbird/Client.scala with

package com.twitter.newbird

import com.twitter.finagle.builder.ClientBuilder
import com.twitter.finagle.thrift.ThriftClientFramedCodec
import com.twitter.newbird.thrift._
import org.apache.thrift.protocol.TBinaryProtocol

import java.net.InetSocketAddress

class Client {

  val service = ClientBuilder().hosts(Seq(newInetSocketAddress("localhost",9999)))
    .codec(ThriftClientFramedCodec())
    .hostConnectionLimit(1)
    .build()
  val client = new NewbirdServiceClientAdapter(
    new thrift.NewbirdService.ServiceToClient(service,newTBinaryProtocol.Factory))

  def get(key:String) = client.get(key)()
  def put(key:String, value:String) = client.put(key,value)()

}

Running the server

$ cd newbird
$ sbt> run -f config/development.scala

Playing with the client

$ cd newbird
$ sbt console
scala> import com.twitter.newbird.Client
scala> val client = new Client()
scala> client.put("foo","bar")
scala> client.get("foo")

Bonus

finagle exports a stats url you can curl:

$ curl http://localhost:9900/stats.txt
counters:  Newbird/connects: 1
Newbird/requests: 4
Newbird/success: 4
gauges:
  Newbird/connections: 0
  Newbird/pending: 0
  jvm_heap_committed: 588251136
  jvm_heap_max: 2146828288
  jvm_heap_used: 64354560
  jvm_nonheap_committed: 83267584
  jvm_nonheap_max: 318767104
  jvm_nonheap_used: 68655360
  jvm_num_cpus: 4
  jvm_start_time: 1327511164928
  jvm_thread_count: 14
  jvm_thread_daemon_count: 9
  jvm_thread_peak_count: 14
  jvm_uptime: 2626505
labels:
  metrics:
    Newbird/connection_duration: (average=2590412, count=1, maximum=2590412, minimum=2590412, p25=2590412, p50=2590412, p75=2590412, p90=2590412, p99=2590412, p999=2590412, p9999=2590412)
    Newbird/connection_received_bytes: (average=192, count=1, maximum=192, minimum=192, p25=192, p50=192, p75=192, p90=192, p99=192, p999=192, p9999=192)
    Newbird/connection_requests: (average=4, count=1, maximum=4, minimum=4, p25=4, p50=4, p75=4, p90=4, p99=4, p999=4, p9999=4)
    Newbird/connection_sent_bytes: (average=120, count=1, maximum=120, minimum=120, p25=120, p50=120, p75=120, p90=120, p99=120, p999=120, p9999=120)
    Newbird/request_latency_ms: (average=14, count=4, maximum=39, minimum=2, p25=2, p50=8, p75=10, p90=39, p99=39, p999=39, p9999=39)

Render image links directly inside Adium

2011-09-13T08:59:00Z

Render image links directly inside Adium

Last night I delightfully discovered that Adium Message Styles are just html, css, and javascript rendered inside a webview. The next natural step was to write something in it, so I wrote a Message Style that tries to render any image link directly inline the conversation (campfire style).

The code was written at midnight after a long day, so its not best. Basically, it’s a setInterval that runs every 2.5 seconds that loops through all message elements, appending an img tag to the body of the message if an image link is detected. It also removes the processing class as to not reprocess the same messages.

Installation is simple, just download: (no longer available)

and extract into ~/Library/Adium 2.0/Message Styles (create if necessary). Then choose the TOP Stockholm theme (no idea why there are two entries), and close your chat window. It should be activated next time a chat window opens.

MigrationFor: Write migrations right from the command line!

2011-01-03T09:48:00Z

MigrationFor: Write migrations right from the command line!

As someone who mostly stays in the rails console, I’ve always hated forgetting a field, creating a migration, finding it among your other 500 migration files, then adding the one line you need to add, then running it. This is probably the most annoying part of the Rails experience. I’ve always wanted to write a better migration generator that could take a list of commands/fields and write the migration for you, since most of the time what you name a migration has all the info it needs (add_index_to_post_id). Thanks to the heavily refactored plugin/generator API in Rails 3, I was able to do just that.

Let’s take a look at how it works:

First, install it (only works for Rails 3)

rails plugin install git://github.com/capotej/migration_for.git

Then, you can create migrations like so:

rails g migration_for add_index:posts:posts_id

It would generate db/migrate/20110103182654_add_index_posts_posts_id.rb):

class AddIndexPostsPostsId < ActiveRecord::Migration

  def self.up
    add_index 'posts','posts_id'
  end

  def self.down
    #waiting for reversible migrations in rails 3.1!
  end

end

Which you can then run normally with rake db:migrate

Let’s look at a more complex example:

$ rails g migration_for create_table:posts add_column:posts:title:string add_column:posts:user_id:integer

Would generate:

class CreateTablePostsaddColumnPostsTitleStringaddColumnPostsUserIdIntegeraddIndexPostsUserId < ActiveRecord::Migration

  def self.up
    create_table 'posts'
    add_column 'posts','title','string'
    add_column 'posts','user_id','integer'
    add_index 'posts','user_id'
  end

  def self.down
    #waiting for reversible migrations in rails 3.1!
  end

end

It uses a lookup table with all the activerecord transformations and will only insert an expression into a migration if the method name is valid and it has the right number of arguments, so botched commands wont mess up the migration. Hope you enjoy it as much as I have!

Source available here: https://github.com/capotej/migration_for

What I released in 2010

2010-12-31T13:29:00Z

What I released in 2010

Here’s a recap of what I’ve worked on and released in 2010:

Youtube Fraiche

I couldn’t find a youtube downloader that worked on github, so I wrote my own one evening

Uploadd and paperclip_uploadd

I wanted to upload and store images off-site (using paperclip/rails) on an server which has cheaper bandwidth rates than S3. Using rainbows, this tiny rack script has handled over a 1.5 million uploads at a peak of 10-15 uploads/sec. Also, it’s been running for about 6 months now without a single crash. Thank you Eric Wong! There is also a plugin for the popular paperclip gem to use uploadd as a storage backend transparently.

mrskinner

Tiny javascript for making the site gutters clickable based on a fixed width layout

existential

Completely inspired by Nick Kallen’s post on authorization, I wanted to extract that pattern into a rails plugin that I could use for all my projects. I use devise/existential for all my projects now.

has_opengraph

Easy way to participate in opengraph and draw facebook like buttons. Just annotate your models with meta data, and draw it in your view easily.

chewbacca

I kinda feel bad that I took a cool name for such a lame script. Anyway it’s a set of rake tasks that provide a hair of abstraction above scp. Useful when you have a set of files locally that map to a different set of files remotely.

I already have tons of stuff in the works for 2011!

Using Rack applications inside GWT Hosted mode

2009-07-19T18:51:00Z

Using Rack applications inside GWT Hosted mode

This guide will show you how you can use JRuby to run any Rack application inside Google Web Toolkit’s (GWT) hosted mode server so your interface and your backend are of the Same Origin.

BackgroundGWT has two ways of interacting with a server: GWT Remote Procedure Call (RPC) and plain HTTP (XHR). GWT-RPC is a high level library designed for interacting with server-side Java code. GWT-RPC implements the GWT Remote Service interface allowing you to call those methods from the user interface. Essentially, GWT handles the dirty work for you. However, it only works on Java backends that can implement that interface. Since most of my backends are Sinatra/Rack applications, I’ll be using the plain HTTP library.

The problemDue to the restriction of the Same Origin policy, the interface served out of GWT’s development, or Hosted Mode server can only make requests back to itself. If you were using real servlets or GWT’s RemoteService this wouldn’t be an issue; but since Rack applications listen on their own port, you cannot make requests from GWT to our application without resorting to something like JSONP or server-side proxying. This leaves you having to compile our interface to HTML/JS/CSS, which is lengthy process, and serve it from the origin of the Rack application to see our changes.

The solutionSince I wanted to develop using GWT’s development environment with a Rack backend, I devised a way to use jruby-rack to load arbitrary Rack applications alongside our interface.

First let’s setup our environment:

Download and unpack the latest GWT for your platform (mine’s being linux)

wget http://google-web-toolkit.googlecode.com/files/gwt-linux-1.7.0.tar.bz2
tar -xvjpf gwt-linux-1.7.0.tar.bz2cd gwt-linux-1.7.0

Download the latest jruby-complete.jar

wget http://repository.codehaus.org/org/jruby/jruby-complete/1.3.1/jruby-complete-1.3.1.jar
mv jruby-complete-1.3.1.jar jruby-complete.jar

Download the latest jruby-rack.jar

wget http://repository.codehaus.org/org/jruby/rack/jruby-rack/0.9.4/jruby-rack-0.9.4.jar
mv jruby-rack-0.9.4.jar jruby-rack.jar

Create an app with webAppCreator

./webAppCreator -out MySinatra com.example.MySinatra
cd MySinatra

Package gem dependencies

In order for this to work you have to package any gem dependencies your backend needs (sinatra, in our case) as jars within your application. For Sinatra it looks like this:

java -jar jruby-complete.jar -S gem install -i ./sinatra sinatra --no-rdoc --no-ri
jar cf sinatra.jar -C sinatra .

Add jruby-complete.jar, jruby-rack.jar, sinatra.jar (and any other jars you’ve created) to the libs target of your build.xml

<target name="libs" description="Copy libs to WEB-INF/lib">
  <mkdir dir="war/WEB-INF/lib" />
  <copy todir="war/WEB-INF/lib" file="${gwt.sdk}/gwt-servlet.jar" />
  <!-- Add any additional server libs that need to be copied -->
  <copy todir="war/WEB-INF/lib" file="${gwt.sdk}/jruby-complete.jar" />
  <copy todir="war/WEB-INF/lib" file="${gwt.sdk}/jruby-rack.jar" />
  <copy todir="war/WEB-INF/lib" file="${gwt.sdk}/sinatra.jar" />
</target>

Add these lines right after in war/WEB-INF/web.xml

<context-param>
  <param-name>rackup</param-name>
  <param-value>
    require 'rubygems'
    require './lib/sinatra_app'
    map '/api' do
      run MyApp
    end
  </param-value>
</context-param>
<filter>
  <filter-name>RackFilter</filter-name>
  <filter-class>org.jruby.rack.RackFilter</filter-class>
</filter>
<filter-mapping>
  <filter-name>RackFilter</filter-name>
  <url-pattern>/api/*</url-pattern>
</filter-mapping>
<listener>
  <listener-class>org.jruby.rack.RackServletContextListener</listener-class>
</listener>

Note: All you’re doing here is passing the contents of a config.ru file into the <param-value> element for the <context-param> (make sure this is HTML encoded!). This states that any request to /api is to be handled by your Sinatra application and not GWT’s Hosted mode servlet.

Create your Sinatra backend and place it in war/WEB-INF/lib/sinatra_app.rb

require 'sinatra'
require 'open-uri'
class MyApp < Sinatra::Base
  get '/showpage' do
    open('http://www.yahoo.com').read
  end

  get '/helloworld' do
    'hello world'
  end
end

Run your new awesome setup

ant hosted

Now when navigate to http://localhost:8888/api/helloworld or http://localhost:8888/api/showpage you should see the Sinatra application being served via GWT.

Useful Rails Routing tips

2009-01-02T15:50:00Z

Useful Rails Routing tips

Even though I have been using Rails for fun and profit for about 2 years now, I felt I never really used it’s routing engine to its full potential. So I checked out new Rails Routing from the outside in guide and discovered bunch of useful tricks that I (and maybe you) had no idea you could do. Here they are:

Multiple resource definitions on a single line

map.resources :photos, :books, :videos

Impose a certain format for resource identifiers

map.resources :photos, :requirements => { :id => /[A-Z][A-Z][0-9]+/ }

This way, /photos/3 would not work, but /photos/DA321 would.

Friendlier action names

Say for your application ‘create’ and ‘change’ make more sense than the default ‘new’ and ‘edit’ you can do

map.resources :photos, :path_names => { :new => 'make', :edit => 'change' }

You can also do this site-wide also, in your environment.rb

config.action_controller.resources_path_names = { :new => 'make', :edit => 'change' }

Trim the fat off resources with :only and :except

When you use map.resources, rails generates 7 restful routes for that resource; But what if that resource only needed to be seen and listed, never edited or created?

map.resources :photos, :only => [:index, :show]

If your application uses a lot of map.resources calls but not necessarily all its generated routes, you can save memory this way.

Adding extra routes to your resources

Instead of fighting the map.resources generator by placing a horror like this atop your routes.rb

map.connect '/photos/:id/preview', { :controller => 'photos', :action => 'preview' }

You can do this to your already mapped resource

map.resources :photos, :member => { :preview => :get }

This will map all GET’s to /photos/3 to the preview action of your photos controller

This can also be used in collections instead of singular members, just change :member to :collection

map.resources :photos, :collection => { :search => :get }

This will give you /photos/search and hit the search action within the photos controller

So you want to click that button?

2008-10-28T21:05:00Z

So you want to click that button?

I stumbled uponhttp://clickthatbutton.com during my routine lurking ofhacker news . After being amused for about 10 seconds, I decided to take it to the next level; I wanted to click on it really, really fast. After going through a few solutions (simple js while loop in firebug, then curl/wget) and failing, the idea of using selenium popped into my head. So I went off to theirsite and installed the extension. I figured a simple recording of the mouse event, then wrapping it around a loop in selenium would do the trick, but I quickly found that selenium doesn’t support loops. Not to be stopped, I searched google and ended up withthis . After installing the plugin for selenium (a plugin for a plugin!?) and restarting firefox, I tried it again and to my surprise it worked! The click counter was going up steadily on its own (18k clicks and counting). Here is my selenium test case for those of you following along:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en" lang="en">
<head profile="http://selenium-ide.openqa.org/profiles/test-case">
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
<link rel="selenium.base" href="http://clickthatbutton.com/" />
<title>haha</title>
</head>
<body>
<table cellpadding="1" cellspacing="1" border="1">
<thead>
<tr><td rowspan="1" colspan="3">haha</td></tr>
</thead><tbody>
<tr>
    <td>open</td>
    <td>/</td>
    <td></td>
</tr>
<tr>
    <td>store</td>
    <td>x</td>
    <td>1</td>
</tr>
<tr>
    <td>while</td>
    <td>storedVars['x'] == storedVars['x']</td>
    <td></td>
</tr>
<tr>
    <td>click</td>
    <td>submit</td>
    <td></td>
</tr>
<tr>
    <td>endWhile</td>
    <td></td>
    <td></td>
</tr>

</tbody></table>
</body>
</html>

Just paste that into a file, open it with selenium ide, hit play and you should be good to go.

Arrow key navigation for text fields

2008-10-12T17:41:00Z

Arrow key navigation for text fields

Here is a class for enabling the use of arrow keys to navigate through a grid of input fields: (using mootools)

var FocusMover = new Class({

        initialize: function(sel, col_num){

                this.sel = sel
                this.col_num = col_num
                this.inputs = $$(this.sel)
                this.current_focus = 0

                var self = this

                this.inputs.each(function(item, index){
                        item.addEvent('keydown',function(key){
                                $try(function(){
                                        self[key.key]()
                                })
                        })
                        item.addEvent('focus',function(e){
                                self.refresh(e)
                        })

                        item.set('myid', index)
                })

                this.inputs[0].focus()

        },


        refresh: function(e){
                this.current_focus = e.target.get('myid')
        },

        down: function(){
                i = parseInt(this.current_focus) + parseInt(this.col_num)
                this.inputs[i].focus()
        },

        up: function(){
                i = parseInt(this.current_focus) - parseInt(this.col_num)
                this.inputs[i].focus()
        },

        left: function(){
                i = parseInt(this.current_focus) - 1
                this.inputs[i].focus()
        },

        right: function(){
                i = parseInt(this.current_focus) + 1
                this.inputs[i].focus()
        }

})

As you can see, the constructor takes two arguments: a selector (which should return a list of all your input fields), and the number of input field columns. So for a 4x2 table, you would set it up like this:

var FM = new FocusMover('#mytable input', 4)

Tabbing through fields vertically

2008-10-11T01:54:00Z

Tabbing through fields vertically

Sometimes it’s useful to switch the browser’s default tabbing behavior (left to right) to the opposite (top to bottom) when your input fields are in a grid layout instead the of the usual single column layout. Having to do this manually is a real pain, especially for large grids; So here is a solution in javascript, using mootools:

window.addEvent('domready', function(){
    var trs = $$('#mytable tr')
    var accum = 0
    trs.each(function(tr, trindex){
        accum = trindex + 1
        tr.getChildren().each(function(td, tdindex){
            td.getChildren('input')[0].tabIndex = accum
            accum = accum + trs.length
        })
    })
})

Why MooTools (or Why not JQuery)

2008-09-30T10:26:00Z

Why MooTools (or Why not JQuery)

I’ve been toying around with MooTools a bit lately, and I’ve found the experience quite enjoyable and refreshing. Naturally, I twittered about it and went along my merry way. Moments later (and much to my surprise), I had a direct message from John Resig himself asking “Why, what’s wrong with jQuery?”. I was pretty taken aback that he would take time from his surely busy day to message a total stranger in an effort to improve his project or at least gain an insight in the everyday life of a js developer (it’s not like DHH would personally message people that are dumping rails to use merb). I figured he deserved a straight, honest answer; One that at least would be longer than 140 characters (even though I managed to use every single one). So it begs the question, Why MooTools?

Class support. JQuery’s SQL-like syntax is fine for quick and dirty javascripting, but eventually you’ll want real classes to structure your UI logic.
It smells, feels and tastes like regular javascript. JQuery doesn’t even look like javascript, which isn’t necessarily a bad thing, since that’s kind of their goal. MooTools however, feels like just an extension of the language
Faster. ‘Nuff Said EDIT: This was pointed out to be false; It is only faster in certain cases (such as mine, WebKit nightly on OS X).
Robert Penner’s easing equations baked right in.This could just be me, but I find the animations that mootools creates are alot smoother than JQuery’s (especially the easing).
Creating new DOM elements is a snap.Need to create a dom element? var el = new Element(‘a’, { ‘href’: ‘juliocapote.com’}); Done.
Modular. I like that I can just build and pull down a moo.js that only contains the functionality I need.
Better Documented.Or at least, its faster to find what you need.
Easier to hack on and extend. While I haven’t personally delved into the internals of either system, the consensus seems to be that jquery is an unintelligible mess when it comes to modifying how it works.
Prototype Approach (versus a namespaced approach) This is really just matter of preference; MooTools achieves it’s magic by just extending the prototypes of common objects (Array, String, etc); While this is obstrusive, it makes for shorter, more natural code. JQuery does its thing via a main object (which you can name, hence the namespace), that you wrap around whatever you want to make magical; This is unobtrusive, but you pay for that by having to wrap anything you want to use (which ends up being everything). It basically boils down to arr.each(fn) vs $.each(arr, fn)
It’s not a revolution. It feels as if JQuery is trying to take on the world (it seems like it too, since its now included with visual studio and the nokia sdk). However, I’m not; I’m just trying to write some javascript here.

It’s not like I’m never going to use JQuery again; It simply isn’t my default js framework any longer.

Highlight link based on current page in rails

2008-09-27T00:00:00Z

Highlight link based on current page in rails

This is common pattern in website navigation, where it highlights the link (usually by setting class=”active”) that took you to the current page while you are on that page.

First, define a helper:

def is_active?(page_name)
  "active" if params[:action] == page_name
end

Then call it in your link_to’s in your layout as such:

link_to 'Home', '/', :class => is_active?("index")
link_to 'About', '/about', :class => is_active?("about")
link_to 'contact', '/contact', :class => is_active?("contact")

This effect is achieved due to how link_to handles being passed nil for its :class, so when `is_active?returnsnil(because its not the current page),link_tooutputs nothing as its class (notclass=””` as you might expect).

Julio Capote's Blog - Feed

The first thing I've been adding to AGENTS.md

The first thing I’ve been adding to AGENTS.md

Running an aarch64 Fedora VM on MacOS using QEMU 10

Running an aarch64 Fedora VM on MacOS using QEMU 10

“Works on my machine”

ARM Architecture

Steps

Install QEMU

Download Fedora Server filesystem image

Resize the Fedora Server filesystem image

Create a startup script start.sh

Argument Explanation

Start the VM

Configure Fedora Server

SSH from Host OS

Grow Guest filesystem to use new size

Extend the partition

Extend the physical volume

Extend the logical volume

Resize the filesystem

Verify extra space

Shutting down the VM

Headless Mode

Tmux Session Coloring

Tmux Session Coloring

Golang HTTP Handlers as Middleware

Golang HTTP Handlers as Middleware

Playing with groupcache

Playing with groupcache

What groupcache is not

What it is

How to use it

Running the demo

Setup

Start database server

Start Multiple Frontends

Use the CLI to play around

Node failure

Conclusion / Use cases

Automatic High Quality Releases

Automatic High Quality Releases

The source of truth

The app generator

The example app

Updating the README

Announcing Finatra 1.0.0

Announcing Finatra 1.0.0

The API

A super quick demo

Heroku integration

Base: A Scala Project Generator

Base: A Scala Project Generator

Riak at Posterous

Riak at Posterous

An Embedded Key/Value Store for Shell Scripts

An Embedded Key/Value Store for Shell Scripts

How it works

Finagle with scala-bootstrapper

Finagle with scala-bootstrapper

Install scala 2.8.1

Install sbt 0.7.4 (assumes you have a ~/bin in your $PATH)

Install scala-bootstrapper

Generate finagle project**

Add a Client class

Running the server

Playing with the client

Bonus

Render image links directly inside Adium

Render image links directly inside Adium

MigrationFor: Write migrations right from the command line!

MigrationFor: Write migrations right from the command line!

What I released in 2010

What I released in 2010

Youtube Fraiche

Uploadd and paperclip_uploadd

mrskinner

existential

has_opengraph

chewbacca

Create a startup script `start.sh`