Kyle Conroy's Blog

Making open source easy with Codespaces

2022-02-12T00:00:00Z

As of today, if you have a GitHub account (with access to Codespaces), you can start contributing to sqlc in three minutes.

Go to kyleconroy/sqlc
Click the "Code" dropdown and click "New Codespace"
Wait ~75 seconds
Run make test
Wait ~100 seconds
Repeat

Are Codespaces perfect? Absolutely not. My personal laptop is about 4x faster than my Codespace VM. Iterating on the codespace configuration is slow, requiring a new codespace on every change. Codespaces, while built on open source, is not open source itself. If this was the only way to develop, you're tied completely to GitHub.

But good enough is amazing. A first-time contributor doesn't need to know anything about sqlc's development dependenceis. While there are only two (Go and Docker), a codespace will be ready in time before Docker Desktop finishes downloading. No need to worry about OS, system architecture, or conflicts with existing software.

0001-01-01T00:00:00Z

Introducing sqlc - Compile SQL queries to type-safe Go

2019-12-11T00:00:00Z

Ask any Go developer and they will tell you how painful it is to write programs that talk to SQL databases. Go feels like it isn't even half as productive compared to working with toolkits like SQLAlchemy, Diesel, Hibernate or ActiveRecord. The existing tools in the Go ecosystem force application developers to hand-write mapping functions or litter their code with unsafe empty interfaces.

Introducing sqlc

I've been feeling this pain for years, so six months ago I started developing a solution. Today, I'm excited to announce the result of that work. sqlc is a new tool that makes working with SQL in Go a joy.

It dramatically improves the developer experience of working with relational databases without sacrificing type-safety or runtime performance. It does not use struct tags, hand-written mapper functions, unnecessary reflection or add any new dependencies to your code. In fact, it even provides correctness and safety guarantees that no other SQL toolkit in the Go ecosystem can match.

sqlc accomplishes all of this by taking a fundamentally different approach: compiling SQL into fully type-safe, idiomatic Go code. sqlc can take this SQL:

CREATE TABLE authors (
  id   BIGSERIAL PRIMARY KEY,
  name text      NOT NULL,
  bio  text
);

-- name: GetAuthor :one
SELECT * FROM authors
WHERE id = $1 LIMIT 1;

and generate the following Go code automatically.

package db

import (
  "context"
  "database/sql"
)

type Author struct {
  ID   int64
  Name string
  Bio  sql.NullString
}

const getAuthor = `-- name: GetAuthor :one
SELECT id, name, bio FROM authors
WHERE id = $1 LIMIT 1
`

type Queries struct {
  db *sql.DB
}

func (q *Queries) GetAuthor(ctx context.Context, id int64) (Author, error) {
  row := q.db.QueryRowContext(ctx, getAuthor, id)
  var i Author
  err := row.Scan(&i.ID, &i.Name, &i.Bio)
  return i, err
}

For years, software engineers have been generating SQL queries from annotated objects in programming languages. SQL is already a structured, typed language; we should be generating correct, type-safe code in every programming language from the source of truth: SQL itself.

Problems using SQL from Go, today

Working with relational databases in any programming language is challenging. Go in particular is especially painful; even with the existing packages and tools, writing and maintaining queries in a Go application is a chore.

Low-level standard library

Go’s standard library offers the database/sql package for interacting with relational databases, but most applications outgrow the database/sql package and reach for a full-fledged ORM or a higher-level library abstraction. Why?

Using the database/sql package is straightforward. Write a query, pass in the necessary arguments, and scan the results back into fields. Programmers are responsible for explicitly specifying the mapping between a SQL field and its value in the program for both inputs and outputs.

Once an application has more than a few queries, maintaining these mappings is cumbersome and severely impacts programmer productivity. Worse, it's trivial to make mistakes that are not caught until runtime. If you switch the order of parameters in your query, the parameter mapping must be updated. If a column is added to a table, all queries must be updated to return that value. If the type in SQL does not match the type in your code, failures will not occur until query execution time.

Higher-level libraries

The Go community has produced higher-level libraries (github.com/jmoiron/sqlx) and ORMs (github.com/jinzhu/gorm) to solve these issues. However, higher-level libraries still require manual mapping via query text and struct tags that, if incorrect, will only fail at runtime.

ORMs do away with much of the manual mapping but require you to write your queries now in a pseudo-sql DSL that basically reinvents SQL in a set of Go function calls.

Invalid SQL

With either approach, it is still trivial to make errors that the compiler can't check. As a Go programmer, have you ever:

Mixed up the order of the arguments when invoking the query so they didn't match up with the SQL text
Updated the name of a column in one query both not another
Mistyped the name of a column in a query
Changed the number of arguments in a query but forgot to pass the additional values
Changed the type of a column but forgot to change the type in your code?

All of these errors are impossible with sqlc. Wait, what? How?

How to use sqlc in 3 steps

You write SQL queries
You run sqlc to generate Go code that presents type-safe interfaces to those queries
You write application code that calls the methods sqlc generates

Seriously, it's that easy. You don't have to write any boilerplate SQL querying code ever again. sqlc generates fully-type-safe idiomatic Go code from your queries. sqlc also prevents entire classes of common errors in SQL code.

During code generation, sqlc parses all of your queries and DDL statements (e.g. CREATE TABLE) so that it knows the names and types of every column in your tables and every expression in your queries. If any of them do not match, sqlc will fail to compile your queries, catching would-be runtime errors before they happen.

Likewise, the methods that sqlc generates for you have a strict arity and correct Go type definitions that match your columns. So if you change a query's arguments or a column's type but don't update your code, it will fail to compile.

A guided tour of sqlc

That all sounds great, but what does it look like in practice?

Download and install

To start, download the latest version of sqlc and add it to your $PATH. You’ll also want to have Go 1.13 installed on your system. Create a new directory for the example project.

$ mkdir sqlc-tour
$ cd sqlc-tour
$ go mod init github.com/kyleconroy/sqlc-tour

Configuration file

sqlc uses a configuration file at the root of your project to store settings. Create sqlc.json with the following contents:

{
  "version": "1",
  "packages": [{
    "schema": "schema.sql",
    "queries": "query.sql",
    "name": "main",
    "path": "."
  }]
}

sqlc will generate a Go package for each entry in the packages list. Each entry has four required properties:

schema
- Path to a SQL file that defines database tables (can also be a directory of SQL files)
queries
- Path to a SQL file with application queries (can also be a directory of SQL files)
name
- The package name to use for the generated code. Defaults to path basename
path
- Output directory for generated code

Write DDL

Let’s build an application for tracking authors. It’s a small application with only a single table. Define the authors table in schema.sql.

-- schema.sql
 CREATE TABLE authors (
  id   BIGSERIAL PRIMARY KEY,
  name text      NOT NULL,
  bio  text
);

Write queries

Your application needs a few queries to create, insert, update and delete author records. Queries are annotated with a small comment that includes a Go method name and the database/sql function to use.

-- query.sql

-- name: GetAuthor :one
SELECT * FROM authors
WHERE id = $1 LIMIT 1;

-- name: ListAuthors :many
SELECT * FROM authors
ORDER BY name;

-- name: CreateAuthor :one
INSERT INTO authors (
  name, bio
) VALUES (
  $1, $2
)
RETURNING *;

-- name: DeleteAuthor :exec
DELETE FROM authors
WHERE id = $1;

Generate code

With just the information stored in these two SQL files, sqlc can now generate database access methods for your application. Make sure that you’re in the sqlc-tour directory and run the following command:

$ sqlc generate

This will generate three files: db.go, models.go, and query.sql.go.

db.go defines a shared interface for using a *sql.DB or *sql.Tx to execute queries, as well as the Queries struct which contains the database access methods.

`db.go`

// db.go
package main

import (
        "context"
        "database/sql"
)

type dbtx interface {
        ExecContext(context.Context, string, ...interface{}) (sql.Result, error)
        PrepareContext(context.Context, string) (*sql.Stmt, error)
        QueryContext(context.Context, string, ...interface{}) (*sql.Rows, error)
        QueryRowContext(context.Context, string, ...interface{}) *sql.Row
}

func New(db dbtx) *Queries {
        return &Queries{db: db}
}

type Queries struct {
        db dbtx
}

func (q *Queries) WithTx(tx *sql.Tx) *Queries {
        return &Queries{
                db: tx,
        }
}

`models.go`

models.go contains the structs associated with the database tables. In this example it contains a single struct, Author.

// models.go
package main

import "database/sql"

type Author struct {
        ID   int64
        Name string
        Bio  sql.NullString
}

`query.sql.go`

query.sql.go contains the data access methods we defined in query.sql. It’s a bit verbose, but this is code you would have had to write yourself!

// query.sql.go
package main

import (
        "context"
        "database/sql"
)

const createAuthor = `-- name: CreateAuthor :one
INSERT INTO authors (
          name, bio
) VALUES (
  $1, $2
)
RETURNING id, name, bio
`

type CreateAuthorParams struct {
        Name string
        Bio  sql.NullString
}

func (q *Queries) CreateAuthor(ctx context.Context, arg CreateAuthorParams) (Author, error) {
        row := q.db.QueryRowContext(ctx, createAuthor, arg.Name, arg.Bio)
        var i Author
        err := row.Scan(&i.ID, &i.Name, &i.Bio)
        return i, err
}

const deleteAuthor = `-- name: DeleteAuthor :exec
DELETE FROM authors
WHERE id = $1
`

func (q *Queries) DeleteAuthor(ctx context.Context, id int64) error {
        _, err := q.db.ExecContext(ctx, deleteAuthor, id)
        return err
}

const getAuthor = `-- name: GetAuthor :one
SELECT id, name, bio FROM authors
WHERE id = $1 LIMIT 1
`

func (q *Queries) GetAuthor(ctx context.Context, id int64) (Author, error) {
        row := q.db.QueryRowContext(ctx, getAuthor, id)
        var i Author
        err := row.Scan(&i.ID, &i.Name, &i.Bio)
        return i, err
}

const listAuthors = `-- name: ListAuthors :many
SELECT id, name, bio FROM authors
ORDER BY name
`

func (q *Queries) ListAuthors(ctx context.Context) ([]Author, error) {
        rows, err := q.db.QueryContext(ctx, listAuthors)
        if err != nil {
                return nil, err
        }
        defer rows.Close()
        var items []Author
        for rows.Next() {
                var i Author
                if err := rows.Scan(&i.ID, &i.Name, &i.Bio); err != nil {
                        return nil, err
                }
                items = append(items, i)
        }
        if err := rows.Close(); err != nil {
                return nil, err
        }
        if err := rows.Err(); err != nil {
                return nil, err
        }
        return items, nil
}

Star expansion

Were you surprised to see SELECT * / RETURNING * in query.sql? sqlc replaces * references with the correct columns when generating code. Take a second look at the createAuthor, listAuthor and getAuthor SQL queries in the example above.

Write your application code

It’s now easy to create, delete and fetch author records. Paste the following into main.go. It should build (go build) without any errors.

package main

import (
  "context"
  "database/sql"
  "fmt"
)

func run(ctx context.Context, db *sql.DB) error {
  q := &Queries{db: db}

  insertedAuthor, err := q.CreateAuthor(ctx, CreateAuthorParams{
        Name: "Brian Kernighan",
        Bio: sql.NullString{
          String: "Co-author of The C Programming Language",
          Valid:  true,
        },
  })
  if err != nil {
        return err
  }

  authors, err := q.ListAuthors(ctx)
  if err != nil {
      return err
  }
  fmt.Println(authors)

  err = q.DeleteAuthor(ctx, insertedAuthor.ID)
  if err != nil {
      return err
  }
  return nil
}

func main() {
    // TODO: Open a connection to your PostgreSQL database
    run(context.Background(), nil)
}

All the above code can be found on in the sqlc-tour repository. A larger, more complicated example application can be found in the ondeck package in the sqlc repository.

Packed with power

Don’t let the previous example’s simplicity fool you. sqlc has support for complex queries and advanced usage patterns:

Transactions and prepared statements
Aggregates, case statements, and common table expressions
RETURNING values from INSERT, UPDATE, and DELETE statements
PostgreSQL types like arrays, enums, timestamps, and UUIDs
Go type overrides for individual columns or PostgreSQL values
Generated structs with JSON tags

How it works

You might be wondering how this all works. It’s not magic, but it’s close: sqlc parses queries using the same parser as your PostgreSQL database.

A first pass uses DDL statements to build an in-memory representation of your database. Next, sqlc parses each query and uses the in-memory representation to determine input parameters and output columns.

This is only possible thanks to the amazing work by Lukas Fittl on pg_query_go. If you need help diagnosing PostgreSQL performance issues, his service pganalyze may be exactly what you need.

What’s next

While it’s still early days, sqlc is ready for production. It’s used for all database access in my own projects:

https://equinox.io - Go application packaging & distribution
https://upcoming.fm - Spotify playlists for your favorite music venues
https://chaincontrol.org - SMS notifications for winter road closures in Tahoe

More importantly, it’s seen adoption in larger companies. Both ngrok and Weave use sqlc to power portions of their stack.

sqlc is a young project in active development. It currently only supports PostgreSQL and Go. However, it's designed to support additional language backends in the future. If you'd like sqlc support for your language of choice, create an issue or send me an email at [email protected].

Lastly, I like to thank the authors of hugsql, pugsql, and protoc, which served as inspiration for sqlc. Without these tools, sqlc would not exist.

Upcoming: Spotify Playlists for Your Favorite Venues

2019-06-02T00:00:00Z

Determined to go to more concerts this year, I wanted a better way to explore local shows. I listen to the majority of my music on Spotify, so I decided to make playlists for each of my favorite venues featuring artists from their upcoming concerts.

Each playlists is updated once a week on Monday. The order is determined by concert date. Once an artist has performed, they're removed from the playlist. I cycle through the top tracks, which means playlists will repeat every few months.

Venues

You can find a list of all venues, and add your own, at https://upcoming.fm.

Implementation

Before writing any code, I manually created a single playlist for the Bill Graham Civic Auditorium. While not much work, I knew this approach wouldn't scale beyond a few venues. Satisfied with the results, I looked into what APIs were available to automate playlist creation.

It turns out Spotify has a fantastic API for search and playlist management. One quick sign up later, I had a developer account and a set of credentials. I've been writing the majority of my side projects in Go recently, so I used the excellent zmb3/spotify package. It didn't take long before I could search for artists by name and create a playlist with a popular song from each artist.

However, Spotify does not have an API for upcoming concerts at venues. For that, I needed Songkick. They have an API, but sign-up is not self-serve. I applied for a developer account and had my key within in a few days. Using the Upcoming events endpoint, I was able to get the names of all upcoming headliners for a given venue. I then plugged that list into my code above and had an automated solution. Spotify.

I wasn't happy with the Go clients for the Songkick API, so I wrote one myself. It's deliberately incomplete, as I only needed to access one endpoint.

I deployed to code to Heroku and have the script run once a week.

PEP 594 Will Break 1 in 30 PyPI Packages

2019-05-29T00:00:00Z

PEP 594 outlines the plan to deprecate and remove packages from the Python standard library. If accepted in its current form, PEP 594 will break 3.8% of all Python 3 packages on PyPI.

As of May 2019 there are 3,604 Python 3 packages on PyPI (out of 94,680) that import packages deprecated by PEP 594.

  total packages: 181225
  valid packages: 178642
python3 packages: 94680
scanned packages: 92779
 broken packages: 3604

The majority of these packages import the parser or imp package. If those two packages were removed from PEP 594, the number of broken packages drops to 828.

Is 3,600 broken packages enough to block adoption of the PEP? I don't know. I just wanted to make sure that the impact the PEP was known before a final decision.

Reproduce the Results

Before you begin, you'll need Python >= 3.6 and a recent version of Go to run the code. All commands should be run inside a cloned checkout of the dead-batteries repository. First, build the binary.

git clone https://github.com/kyleconroy/dead-batteries.git
cd dead-batteries
go build

Next, you'll download the metadata for every package on PyPI, which will take up about ~500MB of space.

./dead-battery mirror

simple.html: contains a list of all known packages on PyPI
meta/*.json: contains package metadata for each package
python3-packages.json: contains a list of packages that support Python3

With a complete mirror, you're now ready to scan packages for imports of deprecated packages. Open up a new shell to install and run the Python service.

python3 -m venv venv
venv/bin/pip install flask
venv/bin/pip install gunicorn
venv/bin/pip install gunicorn[gevent]
venv/bin/gunicorn -k gevent -w 10 -b 127.0.0.1:4000 imports:app

The service exposes a HTTP/JSON interface to the ast package. It parses a given file and returns any deprecated imports as well as parsing errors.

// INPUT
{
  "path": "/path/to/python/file"
}

// OUTPUT
{ 
  "imports": {
    "imp": 2
  },
  "errors": {
    "syntax-error": 2
  }
}

With that running, you can now start the scan. On my laptop, the scan took about an hour to complete. The output is continually saved to results.json.

./dead-battery scan

Once the search process is complete, generate the package statistics.

./dead-battery stats

Two new files have been created: import.csv and packages.json. The CSV file contains the total number of imports for each deprecated standard library package. The JSON file contains a list of every package that imports one of these deprecated packages, along with a link to the package on PyPI.

A quick jump into the Python interpreter gives us the total number of packages affected by PEP 594.

>>> import json
>>> len(json.load(open('packages.json')))
3604

Methodology

Since PEP 594 only affects Python 3, I needed to filter out packages that don't support Python 3. For each package, I first looked for any classifiers with the prefix Programming Language :: Python :: 3. Next, I checked the python_version of the latest release. It's a bit messy, but the code to do so can be found here.

{
    "info": {
        "classifiers": [
            "Programming Language :: Python :: 2.7",
            "Programming Language :: Python :: 3"
        ],
        "version": "2.22.0"
    },
    "releases": {
        "2.22.0": [
            {
                "packagetype": "bdist_wheel",
                "python_version": "py2.py3",
                "url": "https://files.pythonhosted.org/.../requests-2.22.0-py2.py3-none-any.whl"
            }
        ]
    }
}

If you know a better way to check for Python 3 compatibility, please reach out

Downloading Your Twitter Data

2018-07-12T00:00:00Z

After the outcry from my last post reached Jack himself, Twitter launched a new export option that includes all your data in a machine readable format. We did it!

Or did we?

It turns out Jack didn't read my post. I didn't get a call from the Twitter executive team. Instead, it was brought to my attention that the account export I've been looking for already exists and has for some time.

Now, I’m not sure why Twitter has two ways to download your data, but they do. I was using the Tweet archive, available in account settings. The other option, called "Your Twitter Data", is found on a separate settings page behind a password confirmation dialog. Scroll down to the bottom of the page and click the "Download data" button.

This archive contains far more information than the Tweet archive. Uncompressed, my Tweet archive is 7MB. My data archive was 45MB. The information contained inside is higher quality and more numerous. Ad impressions, block lists, screen name changes, oh my! It even includes image descriptions. The full list of files is included at the bottom of this post.

"Machine" Readable

That said, the archive is not without its issues. The most glaring problem is that the data isn't machine readable out of the box. For some reason, records are contained in JavaScript files.

window.YTD.tweet.part0 = [{
   ...
}]

Other strange choices abound. Tweets are contained in tweet.js. Here, all numbers are stored as floats, serialized as strings.

{ "favorite_count" : "0.0" }

I wasn't aware you could half-favorite a tweet. This scheme results in corrupted IDs, as large numbers are stored in E-notation, which truncates digits. Notice that the id filed is missing the last digit present in the id_str field.

{ "id" : "1.01456537218219622E18",
  "id_str" : "1014565372182196224" }

As I update Grain to parse the entire archive, I'm sure I'll run into more issues. I sincerely hope that talking about these data quality problems publicly encourages Twitter and other companies to take account exports seriously.

Appendix: Archive Layout

.
├── README.txt
├── account-creation-ip.js
├── account-suspension.js
├── account.js
├── ad-engagements.js
├── ad-impressions.js
├── ad-mobile-conversions-attributed.js
├── ad-mobile-conversions-unattributed.js
├── ad-online-conversions-attributed.js
├── ad-online-conversions-unattributed.js
├── ageinfo.js
├── block.js
├── connected-application.js
├── contact.js
├── direct-message-headers.js
├── direct-message.js
├── direct_message_media/
├── email-address-change.js
├── facebook-connection.js
├── follower.js
├── following.js
├── ip-audit.js
├── like.js
├── lists-created.js
├── lists-member.js
├── lists-subscribed.js
├── moment.js
├── mute.js
├── ni-devices.js
├── personalization.js
├── profile.js
├── profile_media/
├── protected-history.js
├── saved-search.js
├── screen-name-change.js
├── tweet.js
├── tweet_media/
└── verified.js

Actually Archiving Your Entire Twitter Account

2018-06-30T00:00:00Z

Most social networks give you the option of downloading an archive of all data stored in your account. If you live in the European Union, my understanding is that these services are now required to give you access to this data, thanks in part to GDPR. However, the quality of archives varies from service to service.

Your Twitter Archive

Twitter makes it easy to download an archive of your data. After following four steps, a link to your archive will arrive in your inbox. The ZIP file includes an HTML view of your timeline as well as access to your tweets in CSV format.

Many services allow you to download a human-browsable archive and a machine-readable archive. This commonly looks like a static HTML site for humans and a set of JSON files for machines. Twitter includes both in its archive, but the included data is laughably incomplete.

To me, my Twitter account includes all of the following data:

My tweets, including photos, videos, polls, etc.
My favorites
My public and private lists
The accounts I follow
The accounts that follow me
My direct messages

Of the above, Twitter's account archive only includes partial Tweet data. That's it! No favorites, no lists, no direct messages. The most surprising thing to me was that Twitter does not give you a copy of any of the photos or videos posted to your account. Instead, that data continues to live on Twitter's servers.

When viewing your archive without an internet connection, avatars and images disappear. I guess Twitter hopes you didn't really want to save any of those photos after all.

The Twitter archive does include a tweets.csv file with all of your accounts tweets. However, this format losses much of the information returned via the Twitter API. The documentation details the rich information on each tweet that the archive throws away. Why not use the schema already in use by the API? I'm not sure why Twitter thought a CSV would be an easier format to consume.

Building a Better Archive

Unhappy with my archive, I set out to build one that meets my needs. Using a combination of the Twitter API and official archive, I'm able to create a new archive that contains everything I've done on Twitter. It's called Grain and you can use it today. Your Grain archive includes the following records:

Direct messages
Favorites
Followers
Friends
Lists
Tweets

Most importantly, the archive includes all images associated with the above records. For comparison, here's the data in my official archive versus the archive built via Grain.

Records	Twitter	Grain
tweets	4,348	4,348
favorites		2,281
friends		105
followers		640
direct messages		9
lists		3
images		1,986

The records are stored as JSON, backed by protocol buffers. I'm hoping this makes it easy to build other tools that interact with your archive.

Tweets are stored as the full object returned from the Twitter API, which includes far more information than contained in the official archive. Highlights include a fully hydrated user object and detailed display information.

A few months ago I tweeted about Waymo testing their self-driving cars in my neighborhood.

Waymo testing underway in Dogpatch pic.twitter.com/LaOXpQiLi3
— Kyle Conroy (@kyle_conroy) April 21, 2018

Here's the data for that tweet from the official archive (CSV converted to YAML for readability):

tweet_id: 987812599591878656
in_reply_to_status_id:
in_reply_to_user_id:
timestamp: 2018-04-21 21:57:31 +0000
source: <a href="http://tapbots.com/tweetbot" rel="nofollow">Tweetbot for iΟS</a>
text: Waymo testing underway in Dogpatch https://t.co/LaOXpQiLi3
retweeted_status_id:
retweeted_status_user_id:
retweeted_status_timestamp:
expanded_urls: https://twitter.com/kyle_conroy/status/987812599591878656/photo/1

And the same tweet in the Grain archive:

{
    "created_at": "Sat Apr 21 21:57:31 +0000 2018",
    "display_text_range": [
        0,
        34
    ],
    "entities": {
        "hashtags": [],
        "media": [
            {
                "display_url": "pic.twitter.com/LaOXpQiLi3",
                "expanded_url": "https://twitter.com/kyle_conroy/status/987812599591878656/photo/1",
                "id": "987812583188017152",
                "indices": [
                    "35",
                    "58"
                ],
                "media_url": "http://pbs.twimg.com/media/DbVqT42VMAAK4r3.jpg",
                "media_url_https": "https://pbs.twimg.com/media/DbVqT42VMAAK4r3.jpg",
                "sizes": {
                    "large": {
                        "h": 1024,
                        "resize": "fit",
                        "w": 768
                    },
                    "medium": {
                        "h": 1024,
                        "resize": "fit",
                        "w": 768
                    },
                    "small": {
                        "h": 680,
                        "resize": "fit",
                        "w": 510
                    },
                    "thumb": {
                        "h": 150,
                        "resize": "crop",
                        "w": 150
                    }
                },
                "type": "photo",
                "url": "https://t.co/LaOXpQiLi3"
            }
        ],
        "urls": [],
        "user_mentions": []
    },
    "extended_entities": {
        "media": [
            {
                "display_url": "pic.twitter.com/LaOXpQiLi3",
                "expanded_url": "https://twitter.com/kyle_conroy/status/987812599591878656/photo/1",
                "id": "987812583188017152",
                "indices": [
                    "35",
                    "58"
                ],
                "media_url": "http://pbs.twimg.com/media/DbVqT42VMAAK4r3.jpg",
                "media_url_https": "https://pbs.twimg.com/media/DbVqT42VMAAK4r3.jpg",
                "sizes": {
                    "large": {
                        "h": 1024,
                        "resize": "fit",
                        "w": 768
                    },
                    "medium": {
                        "h": 1024,
                        "resize": "fit",
                        "w": 768
                    },
                    "small": {
                        "h": 680,
                        "resize": "fit",
                        "w": 510
                    },
                    "thumb": {
                        "h": 150,
                        "resize": "crop",
                        "w": 150
                    }
                },
                "type": "photo",
                "url": "https://t.co/LaOXpQiLi3"
            }
        ]
    },
    "full_text": "Waymo testing underway in Dogpatch https://t.co/LaOXpQiLi3",
    "id": "987812599591878657",
    "lang": "en",
    "source": "<a href=\"http://tapbots.com/tweetbot\" rel=\"nofollow\">Tweetbot for i\u039fS</a>",
    "user": {
        "created_at": "Sun Jun 27 16:44:20 +0000 2010",
        "description": "Currently increasing GDP of the internet at @stripe. Formerly StackMachine, Twilio and UC Berkeley.",
        "entities": {
            "url": {}
        },
        "favourites_count": "2298",
        "followers_count": "646",
        "friends_count": "105",
        "id": "160248151",
        "lang": "en",
        "listed_count": "28",
        "name": "Kyle Conroy",
        "profile_background_color": "131516",
        "profile_background_image_url": "http://abs.twimg.com/images/themes/theme14/bg.gif",
        "profile_background_image_url_https": "https://abs.twimg.com/images/themes/theme14/bg.gif",
        "profile_background_tile": true,
        "profile_banner_url": "https://pbs.twimg.com/profile_banners/160248151/1441003908",
        "profile_image_url": "http://pbs.twimg.com/profile_images/691734524355424256/Jsa2rYyB_normal.jpg",
        "profile_image_url_https": "https://pbs.twimg.com/profile_images/691734524355424256/Jsa2rYyB_normal.jpg",
        "profile_link_color": "009999",
        "profile_sidebar_border_color": "EEEEEE",
        "profile_sidebar_fill_color": "EFEFEF",
        "profile_text_color": "333333",
        "profile_use_background_image": true,
        "screen_name": "kyle_conroy",
        "statuses_count": "4086",
        "url": "https://t.co/qOYJRRAPQu"
    }
}

Sadly, it's not a perfect tool due to the limitations of the Twitter API. Direct messages older than 30 days are not available in the API. Without access to the official archive, the tool can only retrieve and store that last 2,300 tweets from your account. I have no idea why Twitter picked such a arbitrary limit.

The archive is also missing some data. I haven't figured out how to archive videos, moments, polls, or saved searches.

I'm hoping that my work will convince Twitter to improve its own archive and make Grain obsolete. If you feel like Twitter should provide you all your data without jumping through hoops, send a message to @TwitterSupport. If you work or worked at Twitter, please reach out if you can put me in contact with the team that owns account archives. I'd love to give them my feedback directly.

Per-Test Database Isolation in Postgres

2017-09-20T00:00:00Z

Over the years, I've tried many different strategies for isolating individual tests at the database layer.

One shared database, but all data is sharded by an account: Works in the short term, but eventually you'll have global tables that aren't scoped to an account.

Creating a new database for each test: Can be slow and error prone. Difficult to ensure all connections have been closed before dropping the database. Some CI providers only provide one logical test database.

Use an in-memory SQLite database: Only works if your application avoids Postgres-specific features. Even then you may still run into runtime differences between database engines.

Truncating the tables between tests: Test parallelization is tricky, if not impossible. No command to truncate all tables, drop all indexes, etc.

Wrap each test in a transaction: Works fine as long as none of your code uses transactions or parallel queries. While Postgres can't nest transactions, some SQL layers simulate support using savepoints.

Give each test a single connection, scoped to temporary tables: Supports individual transactions, but not two open transactions at once. Temporary tables can't be shared across connections.

After trying all these different solutions, I think I've found a winning strategy. Postgres schemas and the search path allow you to isolate tests from each other while using the same logical database. You can think of a schema as a namespace for tables. From the docs:

A database contains one or more named schemas, which in turn contain tables. […] The same object name can be used in different schemas without conflict; for example, both schema1 and myschema can contain tables named mytable.

There are several reasons why one might want to use schemas: […] To allow many users to use one database without interfering with each other

Establish a connection to your database and create a new schema. Here I'm using foo as a placeholder name. In the real world, you'd want to randomly generate a name for each individual test.

CREATE SCHEMA foo

Create a new connection pool to the database and set the search path to only include the new schema.

postgres://localhost/chalkbag?sslmode=disable&search_path=foo

Now you can create as many tables, functions, enums, and indexes as you want, in complete isolation. Once the test is finished, drop the schema. This step is optional if you're using a CI provider that destroys the database at the end of a test run.

DROP SCHEMA foo CASCADE

This strategy only works if you aren't using schemas for other purposes in your application. Here's an example in Go of the above steps.

package main

import (
        "database/sql"

        _ "github.com/lib/pq"
)

func main() {
        dburl := "postgres://localhost/db?sslmode=disable"
        db, err := sql.Open("postgres", dburl)
        if err != nil {
                panic(err)
        }
        if err := provision(db); err != nil {
                panic(err)
        }
}

func provision(db *sql.DB) error {
        // For each test, pick a new schema name at random.
        // `foo` is used here only as an example
        if _, err := db.Exec("CREATE SCHEMA foo"); err != nil {
                return err
        }

        defer func() {
                db.Exec("DROP SCHEMA foo CASCADE")
        }()

        surl := "postgres://localhost/db?sslmode=disable&search_path=foo"
        sdb, err := sql.Open("postgres", surl)
        if err != nil {
                return err
        }

        // Run tests
        _, err = sdb.Exec("SELECT 1")
        return err
}

Using schemas avoids race conditions, makes clean up easy, and requires only a single logical database.

Writing API Clients in Go

2017-09-17T00:00:00Z

The humble API client. A deceptively simple piece of software. Make a request and parse a response. Repeat.

With the rise of public web services, API clients have become the main integration point. However, many of the Go clients I encounter are obtuse. Here's my guide for writing boring API clients that age well.

We'll use the Dropbox Paper API as our example. First, start with a client struct.

type client struct {
    // unexported fields
}

Each API method should be represented as an exported method on the client. We'll use the document download method as our example.

func (c *client) DownloadDoc() {}

The method should have two arguments: a context and a method-specific argument struct. It may feel awkward passing around structs instead of positional arguments, but structs allow you to make additions to methods without making breaking changes to the methods signatures.

type DocExport struct {
    DocID  string
    Format ExportFormat
}

func (c *client) DownloadDoc(ctx context.Context,
    in *DocExport) {
    // implemetation
}

Take special care in avoiding stringly-typed APIs. If a struct field is limited to a set of values, create a new type that encapsulates those values. In this case, the Format field can only have two values: markdown and html.

type ExportFormat string
const (
    ExportFormatMarkdown ExportFormat = "markdown"
    ExportFormatHTML                  = "html"
)

As an added bonus, these types work natively with the encoding/json package.

The method should return two results: a method-specific return value struct and an error.

type DocExportResult struct {
    Owner    string
    Title    string
    Revision int64
    MIME     string
    Content  []byte
}

func (c *client) DownloadDoc(ctx context.Context,
    in *DocExport) (*DocExportResult, error) {
    // implemetation
}

You may have noticed that our client struct isn't exported. Instead of exporting your concrete type, export an interface. Using an interface makes it easier for downstream consumers to mock out calls to your package.

type Client interface {
    DownloadDoc(context.Context, *DocExport) (
        *DocExportResult, error)
}

For increased flexibility, allow users to pass in their own http.Client, as many use cases require a customized HTTP transport.

func NewClient(token string, hclient *http.Client) Client {
    // implementation
}

This isn't the only way to design API clients in Go. Have another style you like more? I'd love to know about it.

Blogging on Paper

2017-08-29T00:00:00Z

I recently published my first blog post of 2017. The fact that it was posted exactly one year after my last post was mere coincidence. Looking over the the last six years of my blog, it's hard to really call it a blog at all.

Year	2011	2012	2013	2014	2015	2016	2017
Number of Posts	0	1	1	2	1	1	1

I think I may change the title to "Kyle Conroy's Personal Yearly Post". I'd love to pretend my posts are so meticulously researched that they take a year to write, but that's not the case. It took me more time to deploy my site than it did to write "I should write a blog post".

One of the reasons for the slow output is my current workflow. I write posts in Markdown using vim, generate HTML using Jekyll, and serve the content via a small web app in Go on Heroku.

There are a few problems with this setup. Starting a new post involves firing up vim and creating a new Markdown file, a process which isn't easy to replicate on mobile. When I'm finished with a draft, I can't easily get feedback from peers unless I open a PR on Github and invite them to my private repository.

At work, we use Hackpad as one of our tools for collaborating on documents. Dropbox bought Hackpad, shut it down, and turned it into Dropbox Paper. Paper feels like Hackpad with all the bugs ironed out. Once I found out that Paper supported exporting documents in Markdown, I decided to try it out for blogging. After writing two posts in Paper, I'm glad I've switched.

I found myself in some long lines at a museum over the weekend. While I was waiting, I worked on few posts using the Paper mobile app. I'm sure there are mobile apps out there for editing Markdown, but I'd need to figure out how to integrate them into my workflow.

Paper also supports inline comments. I was able to ask a few friends for input on the previous post, and they could post comments inline. Many document editing platforms support comments, but I haven't used one before for blogging.

My previous setup is unchanged save for an extra step at the start where I pull down posts from Paper using the API. While the API works, it was some serious short comings:

The markdown export doesn't support fenced code blocks.
The API doesn't return the date a document was created or updated.
Changes to Paper documents don't generate webhooks.
I can't create a read-only API key.

These are minor annoyances now, but may prove problematic in the future. I've also open-sourced my Paper API client written in Go. It's incomplete, but implements enough of the API to export documents.

I've now written two posts within the span of a week. We'll see how long it lasts, but using Paper has made writing more enjoyable.

Progressively Worse Apps

2017-08-28T00:00:00Z

As progress ive web apps become more popular, navigation has become fraught with peril. It's common for apps to make tens of requests to render a single page. Parts of the application load one by one until the entire page is finished. Poor network connections and slow endpoints expose intermediate states to users. Asynchronously loaded page elements shift click targets, resulting in a usability nightmare.

Let's take a look at the how an example application, the Heroku dashboard, suffers from these issues. Here's how the applications list loads.

There are four phases before the page is finished loading. I find the gray layout unnecessary. Just continue to show me the loader, as I can't interact with the page. Without the loader, I'm not sure if the page is still loading.

Besides the fake grey list, the application list page works. I can interact with the page before application metrics load. Once the metrics do load, nothing on the page shifts around or changes place.

The application overview isn't as lucky.

The first problem is the application metrics pane. Like the application list view, metrics are fetched asynchronously. However, here the placeholder is the wrong size. When the metrics load, the pane grows by a small amount. While the change is minimal, it's big enough to disrupt click targets.

The second, larger problem is the add-ons pane. A Heroku application can have unlimited add-ons, making it difficult to size a placeholder element. When the add-ons do load, the dyno pane is pushed further down the page.

The inspiration for this post came from the frustration of having this happen to me. I went to select the worker dyno, but right before I clicked, the add-ons finished loading, causing me to select the web dyno instead.

There a few solutions to this problem.

First, ask yourself if you really need a dynamically-loaded page in the first place. Static pages still work surprisingly well, not matter what Google and Facebook say.

If you do decide to load parts of your page dynamically, make sure your placeholders are correctly sized, both vertically and horizontally. The container shouldn't grow or shrink after the load.

When building and testing your application, throttle your connection to simulate a slow network. This feature is built in to most modern browsers.

Don't cause users to second guess your app. Make navigation consistent under all scenarios.

Generating Code Examples

2016-08-28T00:00:00Z

I've been thinking about a specific problem when writing technical documentation: code examples. In most cases, code examples are written by hand in a single language. If you want to add more languages, you'll need to write more examples. As you write more examples, typos creep in. The code no longer compiles. How can you fix this problem? I have a couple of ideas.

Requirements

For my purposes, I'm looking to write a single code snippet and then generate sample code in a variety of languages. Right now I'm targeting Ruby, Python, Go, Java, Node, C#, PHP, C++, C and Swift. At a minimum, I need support for:

Importing modules
Control flow (if, else, while, for, etc.)
Lists and maps
Calling functions and methods

I don't have a functional language in my list. I'm not sure how you'd translate a code example written in an imperative language to one in a functional language.

Approaches

These are some of the approaches I thought through.

Templates

The first idea that came to mind was templates. Apparently this is how most code generators work. Note that when I say "code generator" here, I'm not talking about machine code. Instead, I'm talking about projects like swagger or gRPC. They take some input and generate a large amount of source code.

I think templates work for these projects because the input is constrained. For example, Swagger ingests a JSON document which describes an API. gRPC and protoc ingest .proto files. These inputs aren't turing-complete programming languages.

We're trying to translate one sample program into many languages.

A DSL

I thought, alright, let's build a DSL. However, most DSLs I've seen are glorified configuration languages. Ansible uses YAML to encode a psuedo-programming language. There are a million gems for creating DSLs in Ruby, but I don't think those are up for the task (would love to be proven wrong).

When writing code examples, we want to be able to use the full power of a turing-complete programming language, but one that has features that cleanly map to all languages we wish to support. This would be a "lowest-common denominator" language, one that can easily be correctly transpiled into many languages.

It wouldn't be a particularly powerful language, but it would allow you to write the basic code you'd need. You could then include macros (or some type of extensions) to generate specific code sections. An example would be initializing a gRPC client. Each language does it in a separate way, but you could abstract it behind a macro.

Use a subset of an existing language

Instead of creating a new language, use a subset of an existing language. For example, Go has a parser built into the standard library. I could write examples in a subset of Go (no goroutines, no type casting, etc.) and generate my code examples that way. The macros I mentioned above aren't super easy to implement, but I could just hardcode them into the "language".

Wrapping up

I'm not particularly happy with any of these ideas.

I can't be the first person to run into this issue. If you've solved this problem (no matter the context) I'd love to hear how you did it.

What if Last Week Tonight aired on PBS?

2016-04-24T00:00:00Z

That isn't to say that Last Week Tonight doesn't report on serious news. It does, but every segment includes plenty of humor (and usually a dick joke). Here's what Last Week Tonight would look like if it aired on the Public Broadcasting Service.

Why Flickr? YouTube marked it as stolen content. Vimeo has a weekly upload limit of 500MB. Dropbox will disable files that get viewed too many times. It's 2016 and sharing video content is still difficult.

I should write a blog post

2015-08-14T00:00:00Z

Wow, I haven’t written a post in a while.

This one will need to be really good, then.

Huh, my blog sure looks outdated.

I can’t write a post with it looking like that.

I need to update the design.

How do I deploy this thing again?

Oh, it’s a full-blown web application.

All blogs today use static site generators.

I should look up the best static site generator and switch to that.

There are a lot of choices, I should figure out how I’m going to migrate my blog.

I’m sure other people have this problem all the time!

I should write a blog post.

HTML ROMs: Self-contained web applications

2014-11-07T00:00:00Z

About a year ago, my friends found out that I had never played Pokemon Red or Blue. After some prodding, I agreed to play, filling a supposed void in my childhood. I was on my way to be the best there ever was.

Thanks to OpenEMU, playing classic video games is easier than ever. All you need is a ROM, which are easy to find via Google. They're even legal if you own the original game. ROMs are self-contained time-capsules. Hours of game play, packed into less than 500k of data.

What if we took the idea of ROMs and applied it to the web? A single HTML file containing a full application, no network connectivity required. 2048, Drowning, and A Dark Room are a few examples that come to mind. These games are great, but how long will they be around? Servers die, domain names expire, and files disappear. The archive team can't always be called upon to ride in and save the day.

The answer is to turn them into single-file web applications: HTML ROMs.

The browser as an emulator

HTML ROMs are self contained applications that live in a single HTML file. They can't include any other files and must work without a network connection. A user should be able to save the file, open it locally, and have everything Just Work.

To see how feasible this idea was, I took some time to make some to convert a few HTML games into single-file applications. Behold, 2048 and Drowning as self-contained single-file applications, that you can enjoy whenever and where ever you have access to a web browser.

Development considerations

First, don't compress or minify JavaScript or CSS. This allows other people to easily remix and change the original application. Drowning is a good example of a game that's hard to change, as the original Dart source-code isn't available.

Images, audio, and video should be base64 encoded into data URIs. The increase in file size is worth the increase in portability. You never need to worry about sending or saving more than one file.

Some tooling will be required to make the above easy. A CSS preprocessor that turns URLs into data URIs. A JavaScript ES6 transpiler to compile individual modules into one larger JavaScript file. Tie them together with your favorite build tool, and your on your way.

Sadly, mobile browsers don't make it easy to save and load HTML files from the file system. An application that wraps a web view with easy loading from the file system wouldn't be too hard to right, and would ensure that mobile users can take advantage of permanent offline access, without developers having to worry about the headache that is AppCache.

Go forth and create

Transform your favorite web game into an HTML ROM. Send me a link and I'll add it to the list below:

The Need for an Open Barcode Database

2014-01-06T00:00:00Z

Next time you're in the store, grab a random product and look turn it around. You'll probably see one of these:

Encoded in that bar code is the product's Global Trade Item Number (GTIN). It's 8-14 digits long and almost every product sold in the world has one of these numbers. They are managed by the GS1, a non-profit organization that manages standards for supply chains. GS1 provides (and controls) the Global Electronic Party Information Registry (GEPIR), the authoritative source for GTINs. The two interfaces to GEPIR are a web portal and a SOAP web service, both of which restrict a user to 20-30 daily requests. There is no option to download the dataset, submit missing item numbers, or correct inaccuracies.

Compare this to OpenStreetMaps, where I can download an entire map of the earth with a single click or add a missing building using their web-based editor.

I'm not the first person to realize how bad the situation is. There are other options out there, but none are the open database that's needed. Most options are just as closed as GEPIR.

The last service on the list, POD, is of interest. It has almost a million indexed items and has a free dump of the data. The data is licensed under the Open Data Commons Open Database License, which is the same license as Open Street Maps. The only issue is that POD doesn't support the crowd-sourcing of its data.

I think OpenStreetMaps solved this problem the right way: get people contributing data and make that data available under an open license.

My idea is an application that let's you scan bar codes and upload GTINs. If the product isn't in the database, just attach a photo and add a short description. The database will be small at first, but once a few hundred people start tagging, it will be the next CueCat.

The Website That Never Was

2013-04-03T00:00:00Z

Expiring domain names make me sad. Those expiry emails are a constant reminder that I had an idea I didn't execute on (sometimes for the better). After my most recent expiry, I thought I'd take a trip through my expired domains and see what could have been.

scrapebook.org

I've toyed with the idea of deleting my Facebook account many times, but I'm always worried about losing the data I've contributed. I wrote a tool to pull that data from Facebook. I discontinued the project (which was only ever half done) once Facebook added the ability to download your data.

kandrandyou.org

After Daniel Ritchie passed, I setup a tumblr for people to submit photos of themselves with The C Programming Language. 23 people submitted images. While I let the domain expire, the ~~tumblr is still up~~

adoptarepo.org

This one hurts. Adopt a Repo was going to the be the best place to find maintainers for your old, abandoned projects. It was going to look just like a pet adoption website, complete with funny commercials. You'd sign in with you Github account, identify your projects, and then the site would add a banner to the README announcing the search for a new maintainer. I still think there is a need for a solution to abandoned projects on Github.

areyouresponsive.com

Are You Responsive served as a developer tool for testing responsive websites. It's ~~still alive~~, but I let the name expire due to low usage and better tools being built into browsers.

dothingstellpeople.com

After reading Carl Lange's great post Do Things, Tell People, I wanted to create a community based around people sharing their most recent creations and getting feedback. Imagine Hacker News but only Show HN posts. I decided against the idea because I didn't like the current state of online community software. I may reboot the idea using Discourse.

stockorshop.com

After my Apple products or stock post, I thought it would be fun to generalize the concept and do it for other products. Game consoles, laptops, cars, and maybe even soda. Decided that I didn't want to be a one trick pony.

anyonecancode.org

Inspired by Anyone Can Cook from Pixar's Ratatouille, Anyone Can Code was going to be a website for teaching beginners how to code. Never got past the idea phase.

castinghawk.com

A site for aspiring actors managing extras work. These actors are inundated with text messages and emails for extra work everyday, with few of these messages relevant. I built a prototype version, but never released it because it relied on email forwarding. I also wanted to use machine learning (via scikit) so that when a user flagged enough job offers, we could get an idea of what items they liked.

codingwithfriends.com

When Github launched their game jam, I wanted to make a crappy social game version of Github. You'd have to buy coins to open pull requests and create repos, and opening issues allowed you to level up as a developer.

Circles of Parity: A History

2011-12-03T00:00:00Z

About two weeks ago reddit user AZxWildcat submitted this awesome image to the College Football subreddit.

Instantly after seeing this, I wanted to know more. How often does this happen? What year did it happen the most? When did this first happen?

Science Time

My initial hypothesis was that circles of parity occur once or twice a season. To test this statement, I needed every college football game score. Ever. Thankfully, the Internet is a wonderful place.

James Howell, College Football Data King

One Google search later and I landed on James Howell's College Football Scores page. This guy has the score of every college football game going back to 1869. Yes, 142 years of football scores. He also maintains a similar data set of conference affliations. I wrote a fabric script to save all the results locally for further processing.

Analysis

After downloading and transforming the data, it was time to start analyzing. For each year I had a JSON representation of the conference affiliations and a CSV file of football scores. The first step was to create a a directed graph for all the games that year. Each node in the graph is a team. Connections to another node inditcate victory.

Next, for each conference, I took a subset of the overall games graph involving only the teams from that conference. In the graph, a circle of parity manifests itself as a cycle which touches every node one time. In graph theory, this is called a Hamiltonian Cycle. To find these cycles, I first enumerated all paths in the graph. Since I made sure to only visit a given node once within a path, a path is a Hamiltonian cycle if and only if its length is equal to the number of nodes in the graph. With just under a hundred lines of Python my solution was complete.

Results

It turns out my initial hypothesis was correct. A circle of parity will likely form once a season. However, after 142 years of football, there are some really interesting data points.

Total circles: 134 in 142 years
Average per year: 0.94
First circle: 1869 between Rutgers and Princeton
Conference with most circles: 16 in the Big Ten
Most in a season: 6 in 2006 with Big 12, Big East, CUSA, MAC, Pac 10, SEC
Largest circle: 16 teams, WAC in 1997

In 1997 there was a circle of parity between all 16 teams in the WAC.

Winner	Loser	Score
Fresno State	Nevada-Las Vegas	46-28
Nevada-Las Vegas	Texas Christian	21-19
Texas Christian	Southern Methodist	21-18
Southern Methodist	Wyoming	22-17
Wyoming	San Diego State	41-17
San Diego State	San Jose State	48-21
San Jose State	Air Force	25-22
Air Force	Colorado State	24-0
Colorado State	Tulsa	44-8
Tulsa	Utah	21-13
Utah	Rice	31-14
Rice	New Mexico	35-23
New Mexico	Texas-El Paso	38-20
Texas-El Paso	Brigham Young	14-3
Brigham Young	Hawaii	17-3
Hawaii	Fresno State	28-16

Absolutely insane.

If you're interested, the full report lists all 134 circles.

Making it Faster

It turns out that finding Hamiltonian cycles is hard. Not just hard, NP-complete hard. Thankfully, my graphs are very limited in size so the report only takes about a minute to generate on my laptop.

Even so, I thought I would give PyPy a chance to work its magic. PyPy is a "fast, compliant alternative implementation of Python" written in Python itself. They aren't lying when they say its fast.

$ time python analyze.py

real        0m52.537s
user        0m51.050s
sys         0m0.066s

$ time pypy analyze.py

real        0m22.758s
user        0m18.952s
sys         0m0.131s

Without changing a line of code, my code saw a 56.6% percent improvement in running time. If you haven't checked out PyPy yet, I suggest you head over the homepage right now and get reading.

Wrapping Up

All my data and code can be found in the circle-of-parity Github repo. Another huge thanks to AZxWildcat, James Howell, and the website where I got some of the cycle detection code (which I have now forgotton).

Blocking that Annoying Bar on Websites

2010-09-20T00:00:00Z

More and more websites are popping up toolbars when you scroll down a certain distance on a page.

I can't stand these annoying bars, some of which are powered by Apture.com

I think Annoy. should be added to that list. If you want to block the Apture bar, simply add

127.0.0.1 www.apture.com

to your hosts file (usually /etc/hosts)

VoiceForms 4000: Wufoo + Twilio = Serious Business

2010-08-31T00:00:00Z

Just finished up hacking on my submission for the Wufoo API contest. VoiceForms 4000 takes any existing Wufoo form and turns it into a phone survey. The app is written in Python, runs on App Engine, and uses Twilio for all the phone magic.

https://voiceforms4000.appspot.com/

Go ahead and fill one of the sample forms and tell me what you think.

jQueried: A Safari 5 Extension

2010-06-08T00:00:00Z

jQueried is a Safari 5 extension in the same vein as the jQuerify bookmarklet. jQueried adds jQuery to the current webpage, a task which can be very useful for debugging.

After finishing my first extension, simple as it is, I am impressed with the simplicity of Safari's extension API. Coupled with Firefox's Jetpack and Chrome's extension system, it looks like the future of browser extensions is all JS + CSS + HTML.

Source is on github: https://github.com/kyleconroy/jqueried

~~Download the extension: http://dl.dropbox.com/u/40773/jqueried.safariextz~~

What if I had bought Apple stock instead?

2010-04-24T00:00:00Z

Currently, Apple's stock is at an all time high. A share today is worth over 40 times its value seven years ago. So, how much would you have today if you purchased stock instead of an Apple product? See for yourself in the table below. A huge thanks to everymac.com for the original prices and release dates. All values are calculated using Apple's current stock price according to http://brivierestockquotes.appspot.com.

I have also released the data set behind the calculations, which include Apple's stock price since 1997 as well as almost all Apple products released since 1997. Code at github.com/kyleconroy/apple-stock.

Big thanks to gojomo at http://news.ycombinator.com/item?id=1291809 for the idea.

Last updated April 1, 2012

Product	Release Date	Original Price	Stock Value Today
Apple Power Macintosh G3 233 Desktop	1997-11-10	$2400.0	$308119
Apple Power Macintosh G3 233 Minitower	1997-11-10	$2400.0	$308119
Apple Power Macintosh G3 266 Desktop	1997-11-10	$2400.0	$308119
Apple Power Macintosh G3 266 Minitower	1997-11-10	$3000.0	$385149
Apple Power Macintosh G3 300 Desktop	1998-03-17	$2750.0	$250191
Apple Power Macintosh G3 300 Minitower	1998-03-17	$2399.0	$218258
Apple Power Macintosh G3 333 Minitower	1998-08-12	$2999.0	$179446
Apple Power Macintosh G3 233 All-in-One	1998-03-31	$1499.0	$130628
Apple Power Macintosh G3 266 All-in-One	1998-03-31	$1799.0	$156771
Apple Power Macintosh G3 300 (Blue & White)	1999-01-05	$1599.0	$88520
Apple Power Macintosh G3 350 (Blue & White)	1999-01-05	$1599.0	$88520
Apple Power Macintosh G3 400 (Blue & White)	1999-01-05	$1999.0	$110664
Apple Power Macintosh G3 450 (Blue & White)	1999-06-01	$2999.0	$160540
Apple Mac Server G3 233 Minitower	1998-03-02	$3349.0	$352881
Apple Mac Server G3 266 Minitower	1998-03-02	$4499.0	$474055
Apple Mac Server G3 300 Minitower	1998-03-17	$4999.0	$454802
Apple Mac Server G3 333 Minitower	1998-09-01	$4599.0	$323250
Apple Mac Server G3 350 (Blue & White)	1999-01-05	$3299.0	$182633
Apple Mac Server G3 400 (Blue & White)	1999-01-05	$4999.0	$276745
Apple Mac Server G3 450 (Blue & White)	1999-06-01	$4999.0	$267602
Apple PowerBook G3 250 (Original/Kanga/3500)	1997-11-10	$5700.0	$731784
Apple PowerBook G3 233 (Wallstreet)	1998-05-06	$2299.0	$181842
Apple PowerBook G3 250 (Wallstreet)	1998-05-06	$2979.0	$235627
Apple PowerBook G3 292 (Wallstreet)	1998-05-06	$4599.0	$363763
Apple PowerBook G3 233 (PDQ - Late 1998)	1998-09-01	$2799.0	$196733
Apple PowerBook G3 266 (PDQ - Late 1998)	1998-09-01	$3499.0	$245934
Apple PowerBook G3 300 (PDQ - Late 1998)	1998-09-01	$4999.0	$351365
Apple PowerBook G3 333 (Bronze KB/Lombard)	1999-05-10	$2499.0	$132473
Apple PowerBook G3 400 (Bronze KB/Lombard)	1999-05-10	$3499.0	$185484
Apple PowerBook G3 400 (Firewire/Pismo)	2000-02-16	$2499.0	$52515
Apple PowerBook G3 500 (Firewire/Pismo)	2000-02-16	$3499.0	$73530
Apple Power Macintosh G4 400 (PCI)	1999-08-31	$1599.0	$58778
Apple Power Macintosh G4 450 (AGP)	1999-08-31	$2499.0	$91862
Apple Power Macintosh G4 500 (AGP)	1999-08-31	$3499.0	$128622
Apple Power Macintosh G4 350 (PCI)	1999-10-13	$1599.0	$59880
Apple Power Macintosh G4 400 (AGP)	1999-10-13	$2499.0	$93583
Apple Power Macintosh G4 350 (AGP)	1999-12-02	$1599.0	$34797
Apple Power Macintosh G4 400 (Gigabit)	2000-07-19	$1599.0	$36396
Apple Power Macintosh G4 450 DP (Gigabit)	2000-07-19	$2499.0	$56882
Apple Power Macintosh G4 500 DP (Gigabit)	2000-07-19	$3199.0	$72815
Apple Power Macintosh G4 450 Cube	2000-07-19	$1799.0	$40948
Apple Power Macintosh G4 500 Cube	2000-07-19	$2299.0	$52329
Apple Power Macintosh G4 466 (Digital Audio)	2001-01-09	$1699.0	$118445
Apple Power Macintosh G4 533 (Digital Audio)	2001-01-09	$2199.0	$153303
Apple Power Macintosh G4 667 (Digital Audio)	2001-01-09	$2799.0	$195132
Apple Power Macintosh G4 733 (Digital Audio)	2001-01-09	$3499.0	$243933
Apple Power Macintosh G4 733 (Quicksilver)	2001-07-18	$1699.0	$97945
Apple Power Macintosh G4 867 (Quicksilver)	2001-07-18	$2499.0	$144064
Apple Power Macintosh G4 800 DP (Quicksilver)	2001-07-18	$3499.0	$201713
Apple Power Macintosh G4 800 (QS 2002)	2002-01-28	$1599.0	$82360
Apple Power Macintosh G4 933 (QS 2002)	2002-01-28	$2299.0	$118416
Apple Power Macintosh G4 1.0 DP (QS 2002)	2002-01-28	$2999.0	$154471
Apple Power Macintosh G4 867 DP (MDD)	2002-08-13	$1699.0	$139539
Apple Power Macintosh G4 1.0 DP (MDD)	2002-08-13	$2499.0	$205243
Apple Power Macintosh G4 1.25 DP (MDD)	2002-08-13	$3299.0	$270947
Apple Power Macintosh G4 1.0 (FW 800)	2003-01-28	$1499.0	$123281
Apple Power Macintosh G4 1.25 DP (FW 800)	2003-01-28	$1999.0	$164403
Apple Power Macintosh G4 1.42 DP (FW 800)	2003-01-28	$2699.0	$221973
Apple Power Macintosh G4 1.25 (MDD 2003)	2003-06-23	$1299.0	$81722
Apple Mac Server G4 350 (AGP)	1999-12-02	$2999.0	$65264
Apple Mac Server G4 400 (AGP)	1999-12-02	$2999.0	$65264
Apple Mac Server G4 450 (AGP)	1999-12-02	$3999.0	$87027
Apple Mac Server G4 500 (AGP)	1999-12-02	$4499.0	$97908
Apple Mac Server G4 450 DP (Gigabit)	2000-07-19	$3999.0	$91025
Apple Mac Server G4 500 DP (Gigabit)	2000-07-19	$4999.0	$113787
Apple Mac Server G4 533 (Digital Audio)	2001-01-09	$2999.0	$209075
Apple Mac Server G4 533 DP (Digital Audio)	2001-01-09	$3999.0	$278790
Apple Mac Server G4 733 (Quicksilver)	2001-09-08	$2799.0	$193111
Apple Mac Server G4 800 DP (Quicksilver)	2001-09-08	$3799.0	$262104
Apple Mac Server G4 933 (QS 2002)	2002-01-28	$2799.0	$144170
Apple Mac Server G4 1.0 DP (QS 2002)	2002-01-28	$3299.0	$169924
Apple Mac Server G4 1.0 DP (MDD)	2002-08-27	$2999.0	$241998
Apple Mac Server G4 1.25 DP (MDD)	2002-08-27	$3499.0	$282345
Apple PowerBook G4 400 (Original - Ti)	2001-01-09	$2599.0	$181189
Apple PowerBook G4 500 (Original - Ti)	2001-01-09	$3499.0	$243933
Apple PowerBook G4 550 (Gigabit - Ti)	2001-10-16	$2199.0	$146327
Apple PowerBook G4 667 (Gigabit - Ti)	2001-10-16	$2999.0	$199561
Apple PowerBook G4 667 (DVI - Ti)	2002-04-29	$2499.0	$125064
Apple PowerBook G4 800 (DVI - Ti)	2002-04-29	$3199.0	$160096
Apple PowerBook G4 867 (Ti)	2002-11-06	$2299.0	$160088
Apple PowerBook G4 1.0 (Ti)	2002-11-06	$2999.0	$208832
Apple PowerBook G4 867 12" (Al)	2003-01-07	$1799.0	$145166
Apple PowerBook G4 1.0 17" (Al)	2003-01-07	$3299.0	$266206
Apple PowerBook G4 1.0 12" (DVI - Al)	2003-09-16	$1599.0	$85749
Apple PowerBook G4 1.0 15" (FW800 - Al)	2003-09-16	$1999.0	$107200
Apple PowerBook G4 1.25 15" (FW800 - Al)	2003-09-16	$2599.0	$139376
Apple PowerBook G4 1.33 17" (Al)	2003-09-16	$2999.0	$160827
Apple PowerBook G4 1.33 12" (Al)	2004-04-19	$1599.0	$67607
Apple PowerBook G4 1.33 15" (Al)	2004-04-19	$1999.0	$84520
Apple PowerBook G4 1.5 15" (Al)	2004-04-19	$2499.0	$105661
Apple PowerBook G4 1.5 17" (Al)	2004-04-19	$2799.0	$118345
Apple PowerBook G4 1.5 12" (Al)	2005-01-31	$1499.0	$23373
Apple PowerBook G4 1.5 15" (SMS/BT2 - Al)	2005-01-31	$1999.0	$31170
Apple PowerBook G4 1.67 15" (Al)	2005-01-31	$2299.0	$35848
Apple PowerBook G4 1.67 17" (Al)	2005-01-31	$2699.0	$42085
Apple PowerBook G4 1.67 15" (DLSD/HR - Al)	2005-10-19	$1999.0	$21814
Apple PowerBook G4 1.67 17" (DLSD/HR - Al)	2005-10-19	$2499.0	$27271
Apple Power Macintosh G5 1.6 (PCI)	2003-06-23	$1999.0	$125760
Apple Power Macintosh G5 1.8 (PCI-X)	2003-06-23	$2399.0	$150925
Apple Power Macintosh G5 2.0 DP (PCI-X)	2003-06-23	$2999.0	$188672
Apple Power Macintosh G5 1.8 DP (PCI-X)	2003-11-18	$2499.0	$146889
Apple Power Macintosh G5 1.8 DP (PCI)	2004-06-09	$1999.0	$79370
Apple Power Macintosh G5 2.0 DP (PCI-X 2)	2004-06-09	$2499.0	$99223
Apple Power Macintosh G5 2.5 DP (PCI-X)	2004-06-09	$2999.0	$119076
Apple Power Macintosh G5 1.8 (PCI)	2004-10-19	$1499.0	$37904
Apple Power Macintosh G5 2.0 DP (PCI)	2005-04-27	$1999.0	$33337
Apple Power Macintosh G5 2.3 DP (PCI-X)	2005-04-27	$2499.0	$41676
Apple Power Macintosh G5 2.7 DP (PCI-X)	2005-04-27	$2999.0	$50015
Apple Power Macintosh G5 Dual Core (2.0)	2005-10-19	$1999.0	$21814
Apple Power Macintosh G5 Dual Core (2.3)	2005-10-19	$2499.0	$27271
Apple Power Macintosh G5 "Quad Core" (2.5)	2005-10-19	$3299.0	$36001
Apple Mac Pro "Quad Core" 2.0 (Original)	2006-08-07	$2199.0	$19616
Apple Mac Pro "Quad Core" 2.66 (Original)	2006-08-07	$2499.0	$22292
Apple Mac Pro "Quad Core" 3.0 (Original)	2006-08-07	$3299.0	$29428
Apple Mac Pro "Eight Core" 3.0 (2,1)	2007-04-04	$3999.0	$25433
Apple Mac Pro "Quad Core" 2.8 (2008)	2008-01-08	$2299.0	$8048
Apple Mac Pro "Eight Core" 2.8 (2008)	2008-01-08	$2799.0	$9799
Apple Mac Pro "Eight Core" 3.0 (2008)	2008-01-08	$3599.0	$12600
Apple Mac Pro "Eight Core" 3.2 (2008)	2008-01-08	$4399.0	$15400
Apple Mac Pro "Quad Core" 2.66 (2009/Nehalem)	2009-03-03	$2499.0	$16954
Apple Mac Pro "Quad Core" 2.93 (2009/Nehalem)	2009-03-03	$2999.0	$20346
Apple Mac Pro "Quad Core" 3.33 (2009/Nehalem)	2009-12-04	$3699.0	$11471
Apple Mac Pro "Eight Core" 2.26 (2009/Nehalem)	2009-03-03	$3299.0	$22382
Apple Mac Pro "Eight Core" 2.66 (2009/Nehalem)	2009-03-03	$4699.0	$31880
Apple Mac Pro "Eight Core" 2.93 (2009/Nehalem)	2009-03-03	$5899.0	$40022
Apple Mac Pro "Quad Core" 2.8 (2010/Nehalem)	2010-07-27	$2499.0	$5673
Apple Mac Pro "Quad Core" 3.2 (2010/Nehalem)	2010-07-27	$2899.0	$6581
Apple Mac Pro "Six Core" 3.33 (2010/Westmere)	2010-07-27	$3699.0	$8397
Apple Mac Pro "Eight Core" 2.4 (2010/Westmere)	2010-07-27	$3499.0	$7943
Apple Mac Pro "Twelve Core" 2.66 (2010/Westmere)	2010-07-27	$4999.0	$11349
Apple Mac Pro "Twelve Core" 2.93 (2010/Westmere)	2010-07-27	$6199.0	$14073
Apple Mac Pro "Quad Core" 2.8 (Server)	2010-11-05	$2999.0	$5669
Apple Mac Pro "Quad Core" 3.2 (Server)	2010-11-05	$3399.0	$6425
Apple Mac Pro "Six Core" 3.33 (Server)	2010-11-05	$4199.0	$7938
Apple Mac Pro "Eight Core" 2.4 (Server)	2010-11-05	$3774.0	$7134
Apple Mac Pro "Twelve Core" 2.66 (Server)	2010-11-05	$5274.0	$9970
Apple Mac Pro "Twelve Core" 2.93 (Server)	2010-11-05	$6474.0	$12239
Apple Xserve G4/1.0	2002-05-14	$2999.0	$140363
Apple Xserve G4/1.0 DP	2002-05-14	$3999.0	$187166
Apple Xserve G4/1.33 (Slot Load)	2003-02-10	$2799.0	$233724
Apple Xserve G4/1.33 DP (Slot Load)	2003-02-10	$3799.0	$317227
Apple Xserve G4/1.33 DP Cluster Node	2003-03-01	$2799.0	$229254
Apple Xserve G5/2.0 (PCI-X)	2004-01-06	$2999.0	$162719
Apple Xserve G5/2.0 DP (PCI-X)	2004-01-06	$3999.0	$216977
Apple Xserve G5/2.0 DP Cluster Node (PCI-X)	2004-01-06	$2999.0	$162719
Apple Xserve G5/2.3 DP (PCI-X)	2005-01-04	$3999.0	$74995
Apple Xserve G5/2.3 DP Cluster Node (PCI-X)	2005-01-04	$2999.0	$56241
Apple Xserve Xeon 2.0 "Quad Core" (Late 2006)	2006-08-07	$2999.0	$26752
Apple Xserve Xeon 2.66 "Quad Core" (Late 2006)	2006-08-07	$0.0	$0
Apple Xserve Xeon 3.0 "Quad Core" (Late 2006)	2006-08-07	$0.0	$0
Apple Xserve Xeon 2.8 "Quad Core" (Early 2008)	2008-01-08	$2999.0	$10499
Apple Xserve Xeon 2.8 "Eight Core" (Early 2008)	2008-01-08	$3499.0	$12250
Apple Xserve Xeon 3.0 "Eight Core" (Early 2008)	2008-01-08	$4299.0	$15050
Apple Xserve Xeon Nehalem 2.26 "Quad Core"	2009-04-07	$2999.0	$15635
Apple Xserve Xeon Nehalem 2.26 "Eight Core"	2009-04-07	$3599.0	$18763
Apple Xserve Xeon Nehalem 2.66 "Eight Core"	2009-04-07	$4999.0	$26062
Apple Xserve Xeon Nehalem 2.93 "Eight Core"	2009-04-07	$6199.0	$32318
Apple Xserve RAID	2003-02-10	$5999.0	$500933
Apple Xserve RAID (SFP)	2004-01-06	$5999.0	$325493
Apple iMac G3/233 Original - Bondi (Rev. A & B)	1998-05-06	$1299.0	$102746
Apple iMac G3/266 (Fruit Colors)	1999-01-05	$1199.0	$66376
Apple iMac G3/333 (Fruit Colors)	1999-04-14	$1199.0	$80952
Apple iMac G3/350 (Slot Loading - Blueberry)	1999-10-05	$999.0	$35253
Apple iMac G3/400 DV (Slot Loading - Fruit)	1999-10-05	$1299.0	$45839
Apple iMac G3/400 DV SE (Slot Loading)	1999-10-05	$1499.0	$52897
Apple iMac G3/350 (Summer 2000 - Indigo)	2000-07-19	$799.0	$18186
Apple iMac G3/400 DV (Summer 2000 - I/R)	2000-07-19	$999.0	$22739
Apple iMac G3/450 DV+ (Summer 2000)	2000-07-19	$1299.0	$29567
Apple iMac G3/500 DV SE (Summer 2000)	2000-07-19	$1499.0	$34120
Apple iMac G3/400 (Early 2001 - Indigo)	2001-02-22	$899.0	$57339
Apple iMac G3/500 (Early 2001 - Flower/Blue)	2001-02-22	$1199.0	$76474
Apple iMac G3/600 SE (Early 2001)	2001-02-22	$1499.0	$95609
Apple iMac G3/500 (Summer 2001 - I/S)	2001-07-18	$799.0	$46061
Apple iMac G3/600 (Summer 2001)	2001-07-18	$999.0	$57591
Apple iMac G3/700 SE (Summer 2001)	2001-07-18	$1499.0	$86415
Apple iMac G4/700 (Flat Panel)	2002-01-07	$1299.0	$68018
Apple iMac G4/800 (Flat Panel)	2002-01-07	$1799.0	$94200
Apple iMac G4/800 17-Inch (Flat Panel)	2002-07-17	$1999.0	$153260
Apple iMac G4/800 - X Only (Flat Panel)	2003-02-04	$1299.0	$106687
Apple iMac G4/1.0 17-Inch (Flat Panel)	2003-02-04	$1799.0	$147752
Apple iMac G4/1.0 15-Inch "FP" (USB 2.0)	2003-09-08	$1299.0	$68497
Apple iMac G4/1.25 17-Inch "FP" (USB 2.0)	2003-09-08	$1799.0	$94862
Apple iMac G4/1.25 20-Inch "FP" (USB 2.0)	2003-11-18	$2199.0	$129255
Apple iMac G5/1.6 17-Inch	2004-08-31	$1299.0	$45148
Apple iMac G5/1.8 17-Inch	2004-08-31	$1499.0	$52100
Apple iMac G5/1.8 20-Inch	2004-08-31	$1899.0	$66002
Apple iMac G5/1.8 17-Inch (ALS)	2005-05-03	$1299.0	$21508
Apple iMac G5/2.0 17-Inch (ALS)	2005-05-03	$1499.0	$24819
Apple iMac G5/2.0 20-Inch (ALS)	2005-05-03	$1799.0	$29787
Apple iMac G5/1.9 17-Inch (iSight)	2005-10-12	$1299.0	$15813
Apple iMac G5/2.1 20-Inch (iSight)	2005-10-12	$1699.0	$20682
Apple iMac "Core Duo" 1.83 17-Inch	2006-01-10	$1299.0	$9631
Apple iMac "Core Duo" 2.0 20-Inch	2006-01-10	$1699.0	$12597
Apple iMac "Core Duo" 1.83 17-Inch (IG)	2006-07-05	$899.0	$9456
Apple iMac "Core 2 Duo" 1.83 17-Inch (IG)	2006-09-06	$999.0	$8552
Apple iMac "Core 2 Duo" 2.0 17-Inch	2006-09-06	$1199.0	$10265
Apple iMac "Core 2 Duo" 2.16 17-Inch	2006-09-06	$1299.0	$11121
Apple iMac "Core 2 Duo" 2.16 20-Inch	2006-09-06	$1499.0	$12833
Apple iMac "Core 2 Duo" 2.33 20-Inch	2006-09-06	$1749.0	$14973
Apple iMac "Core 2 Duo" 2.16 24-Inch	2006-09-06	$1999.0	$17114
Apple iMac "Core 2 Duo" 2.33 24-Inch	2006-09-06	$2249.0	$19254
Apple iMac "Core 2 Duo" 2.0 20-Inch (Al)	2007-08-07	$1199.0	$5323
Apple iMac "Core 2 Duo" 2.4 20-Inch (Al)	2007-08-07	$1499.0	$6655
Apple iMac "Core 2 Duo" 2.4 24-Inch (Al)	2007-08-07	$1799.0	$7987
Apple iMac "Core 2 Extreme" 2.8 24-Inch (Al)	2007-08-07	$2299.0	$10207
Apple iMac "Core 2 Duo" 2.4 20-Inch (Early 2008)	2008-04-28	$1199.0	$4173
Apple iMac "Core 2 Duo" 2.66 20-Inch (Early 2008)	2008-04-28	$1499.0	$5217
Apple iMac "Core 2 Duo" 2.8 24-Inch (Early 2008)	2008-04-28	$1799.0	$6262
Apple iMac "Core 2 Duo" 3.06 24-Inch (Early 2008)	2008-04-28	$2199.0	$7654
Apple iMac "Core 2 Duo" 2.66 20-Inch (Early 2009)	2009-03-03	$1199.0	$8134
Apple iMac "Core 2 Duo" 2.66 24-Inch (Early 2009)	2009-03-03	$1499.0	$10170
Apple iMac "Core 2 Duo" 2.93 24-Inch (Early 2009)	2009-03-03	$1799.0	$12205
Apple iMac "Core 2 Duo" 3.06 24-Inch (Early 2009)	2009-03-03	$2199.0	$14919
Apple iMac "Core 2 Duo" 2.0 20-Inch (Mid-2009)	2009-04-07	$899.0	$4686
Apple iMac "Core 2 Duo" 2.26 20-Inch (Mid-2009)	2010-03-04	$899.0	$2557
Apple iMac "Core 2 Duo" 3.06 21.5-Inch (Late 2009)	2009-10-20	$1199.0	$3616
Apple iMac "Core 2 Duo" 3.33 21.5-Inch (Late 2009)	2009-10-20	$1399.0	$4220
Apple iMac "Core 2 Duo" 3.06 27-Inch (Late 2009)	2009-10-20	$1699.0	$5124
Apple iMac "Core 2 Duo" 3.33 27-Inch (Late 2009)	2009-10-20	$1899.0	$5728
Apple iMac "Core i5" 2.66 27-Inch (Late 2009)	2009-10-20	$1999.0	$6029
Apple iMac "Core i7" 2.8 27-Inch (Late 2009)	2009-10-20	$2199.0	$6633
Apple iMac "Core i3" 3.06 21.5-Inch (Mid-2010)	2010-07-27	$1199.0	$2722
Apple iMac "Core i3" 3.2 21.5-Inch (Mid-2010)	2010-07-27	$1499.0	$3403
Apple iMac "Core i5" 3.6 21.5-Inch (Mid-2010)	2010-07-27	$1699.0	$3857
Apple iMac "Core i3" 3.2 27-Inch (Mid-2010)	2010-07-27	$1699.0	$3857
Apple iMac "Core i5" 2.8 27-Inch (Mid-2010)	2010-07-27	$1999.0	$4538
Apple iMac "Core i5" 3.6 27-Inch (Mid-2010)	2010-07-27	$1899.0	$4311
Apple iMac "Core i7" 2.93 27-Inch (Mid-2010)	2010-07-27	$2199.0	$4992
Apple iMac "Core i5" 2.5 21.5-Inch (Mid-2011)	2011-05-03	$1199.0	$2064
Apple iMac "Core i5" 2.7 21.5-Inch (Mid-2011)	2011-05-03	$1499.0	$2581
Apple iMac "Core i7" 2.8 21.5-Inch (Mid-2011)	2011-05-03	$1699.0	$2925
Apple iMac "Core i5" 2.7 27-Inch (Mid-2011)	2011-05-03	$1699.0	$2925
Apple iMac "Core i5" 3.1 27-Inch (Mid-2011)	2011-05-03	$1999.0	$3441
Apple iMac "Core i7" 3.4 27-Inch (Mid-2011)	2011-05-03	$2199.0	$3786
Apple iMac "Core i3" 3.1 21.5-Inch (Late 2011)	2011-08-08	$999.0	$1695
Apple eMac G4/700	2002-04-29	$999.0	$49995
Apple eMac G4/800	2002-08-13	$1499.0	$123113
Apple eMac G4/800 (ATI)	2003-05-06	$799.0	$54747
Apple eMac G4/1.0 (ATI)	2003-05-06	$999.0	$68451
Apple eMac G4/1.25 (USB 2.0)	2004-04-13	$799.0	$35563
Apple eMac G4/1.42 (2005)	2005-05-03	$799.0	$13229
Apple Mac mini G4/1.25	2005-01-11	$499.0	$9268
Apple Mac mini G4/1.42	2005-01-11	$599.0	$11125
Apple Mac mini G4/1.33	2005-09-27	$499.0	$5598
Apple Mac mini G4/1.5	2005-09-27	$599.0	$6720
Apple Mac mini "Core Solo" 1.5	2006-02-28	$599.0	$5243
Apple Mac mini "Core Duo" 1.66	2006-02-28	$799.0	$6994
Apple Mac mini "Core Duo" 1.83	2006-09-06	$799.0	$6840
Apple Mac mini "Core 2 Duo" 1.83	2007-08-07	$599.0	$2659
Apple Mac mini "Core 2 Duo" 2.0	2007-08-07	$799.0	$3547
Apple Mac mini "Core 2 Duo" 2.0 (Early 2009)	2009-03-03	$599.0	$4063
Apple Mac mini "Core 2 Duo" 2.26 (Early 2009)	2009-03-03	$749.0	$5081
Apple Mac mini "Core 2 Duo" 2.26 (Late 2009)	2009-10-20	$599.0	$1806
Apple Mac mini "Core 2 Duo" 2.53 (Late 2009)	2009-10-20	$799.0	$2410
Apple Mac mini "Core 2 Duo" 2.66 (Late 2009)	2009-10-20	$849.0	$2560
Apple Mac mini "Core 2 Duo" 2.53 (Server)	2009-10-20	$999.0	$3013
Apple Mac mini "Core 2 Duo" 2.4 (Mid-2010)	2010-06-15	$699.0	$1613
Apple Mac mini "Core 2 Duo" 2.66 (Mid-2010)	2010-06-15	$849.0	$1960
Apple Mac mini "Core 2 Duo" 2.66 (Server)	2010-06-15	$999.0	$2306
Apple Mac mini "Core i5" 2.3 (Mid-2011)	2011-07-20	$599.0	$928
Apple Mac mini "Core i5" 2.5 (Mid-2011)	2011-07-20	$799.0	$1238
Apple Mac mini "Core i7" 2.7 (Mid-2011)	2011-07-20	$899.0	$1393
Apple Mac mini "Core i7" 2.0 (Mid-2011/Server)	2011-07-20	$999.0	$1548
Apple iBook G3/300 (Original/Clamshell)	1999-07-21	$1599.0	$70908
Apple iBook G3/366 SE (Original/Clamshell)	2000-02-16	$1799.0	$37805
Apple iBook G3/366 (Firewire/Clamshell)	2000-09-13	$1499.0	$30990
Apple iBook G3/466 SE (Firewire/Clamshell)	2000-09-13	$1799.0	$37192
Apple iBook G3/500 (Dual USB - Tr)	2001-05-01	$1299.0	$60047
Apple iBook G3/500 (Late 2001 - Tr)	2001-10-16	$1199.0	$79784
Apple iBook G3/600 (Late 2001 - Tr)	2001-10-16	$1499.0	$99747
Apple iBook G3/600 14-Inch (Early 2002 - Tr)	2002-01-07	$1799.0	$94200
Apple iBook G3/600 (16 VRAM - Tr)	2002-05-20	$1199.0	$58113
Apple iBook G3/700 (16 VRAM - Tr)	2002-05-20	$1499.0	$72653
Apple iBook G3/700 14-Inch (16 VRAM - Tr)	2002-05-20	$1799.0	$87194
Apple iBook G3/700 (16 VRAM - Op)	2002-11-06	$999.0	$69564
Apple iBook G3/800 (32 VRAM - Tr)	2002-11-06	$1299.0	$90454
Apple iBook G3/800 14-Inch (32 VRAM - Tr)	2002-11-06	$1599.0	$111345
Apple iBook G3/800 (Early 2003 - Op)	2003-04-22	$999.0	$88602
Apple iBook G3/900 (Early 2003 - Op)	2003-04-22	$1299.0	$115209
Apple iBook G3/900 14-Inch (Early 2003 - Op)	2003-04-22	$1499.0	$132947
Apple iBook G4/800 12-Inch (Original - Op)	2003-10-22	$1099.0	$57900
Apple iBook G4/933 14-Inch (Original - Op)	2003-10-22	$1299.0	$68437
Apple iBook G4/1.0 14-Inch (Original - Op)	2003-10-22	$1499.0	$78974
Apple iBook G4/1.0 12-Inch (Early 2004 - Op)	2004-04-19	$1099.0	$46467
Apple iBook G4/1.0 14-Inch (Early 2004 - Op)	2004-04-19	$1299.0	$54923
Apple iBook G4/1.2 14-Inch (Early 2004 - Op)	2004-04-19	$1499.0	$63379
Apple iBook G4/1.2 12-Inch (Late 2004 - Op)	2004-10-19	$999.0	$25261
Apple iBook G4/1.33 14-Inch (Late 2004 - Op)	2004-10-19	$1299.0	$32847
Apple iBook G4/1.33 12-Inch (Mid-2005 - Op)	2005-07-26	$999.0	$13727
Apple iBook G4/1.42 14-Inch (Mid-2005 - Op)	2005-07-26	$1299.0	$17850
Apple MacBook "Core Duo" 1.83 13"	2006-05-16	$1099.0	$10140
Apple MacBook "Core Duo" 2.0 13" (White)	2006-05-16	$1299.0	$11985
Apple MacBook "Core Duo" 2.0 13" (Black)	2006-05-16	$1499.0	$13830
Apple MacBook "Core 2 Duo" 1.83 13"	2006-11-08	$1099.0	$7991
Apple MacBook "Core 2 Duo" 2.0 13" (White/06)	2006-11-08	$1299.0	$9445
Apple MacBook "Core 2 Duo" 2.0 13" (Black)	2006-11-08	$1499.0	$10900
Apple MacBook "Core 2 Duo" 2.0 13" (White/07)	2007-05-15	$1099.0	$6128
Apple MacBook "Core 2 Duo" 2.16 13" (White)	2007-05-15	$1299.0	$7243
Apple MacBook "Core 2 Duo" 2.16 13" (Black)	2007-05-15	$1499.0	$8358
Apple MacBook "Core 2 Duo" 2.0 13" (White-SR)	2007-11-01	$1099.0	$3515
Apple MacBook "Core 2 Duo" 2.2 13" (White-SR)	2007-11-01	$1299.0	$4155
Apple MacBook "Core 2 Duo" 2.2 13" (Black-SR)	2007-11-01	$1499.0	$4794
Apple MacBook "Core 2 Duo" 2.1 13" (White-08)	2008-02-26	$1099.0	$5530
Apple MacBook "Core 2 Duo" 2.4 13" (White-08)	2008-02-26	$1299.0	$6536
Apple MacBook "Core 2 Duo" 2.4 13" (Black-08)	2008-02-26	$1499.0	$7542
Apple MacBook "Core 2 Duo" 2.0 13" (Unibody)	2008-10-14	$1299.0	$7482
Apple MacBook "Core 2 Duo" 2.4 13" (Unibody)	2008-10-14	$1599.0	$9210
Apple MacBook "Core 2 Duo" 2.0 13" (White-09)	2009-01-20	$999.0	$7659
Apple MacBook "Core 2 Duo" 2.13 13" (White-09)	2009-05-27	$999.0	$4501
Apple MacBook "Core 2 Duo" 2.26 13" (Uni/Late 09)	2009-10-20	$999.0	$3013
Apple MacBook "Core 2 Duo" 2.4 13" (Mid-2010)	2010-05-18	$999.0	$2373
Apple MacBook Pro "Core Duo" 1.67 15"	2006-01-10	$1999.0	$14821
Apple MacBook Pro "Core Duo" 1.83 15"	2006-01-10	$2499.0	$18529
Apple MacBook Pro "Core Duo" 2.0 15"	2006-02-14	$2499.0	$22150
Apple MacBook Pro "Core Duo" 2.16 15"	2006-02-14	$2799.0	$24809
Apple MacBook Pro "Core Duo" 2.16 17"	2006-04-24	$2799.0	$25523
Apple MacBook Pro "Core 2 Duo" 2.16 15"	2006-10-24	$1999.0	$14787
Apple MacBook Pro "Core 2 Duo" 2.33 15"	2006-10-24	$2499.0	$18485
Apple MacBook Pro "Core 2 Duo" 2.33 17"	2006-10-24	$2799.0	$20705
Apple MacBook Pro "Core 2 Duo" 2.2 15" (SR)	2007-06-05	$1999.0	$9770
Apple MacBook Pro "Core 2 Duo" 2.4 15" (SR)	2007-06-05	$2499.0	$12213
Apple MacBook Pro "Core 2 Duo" 2.6 15" (SR)	2007-11-01	$2749.0	$8793
Apple MacBook Pro "Core 2 Duo" 2.4 17" (SR)	2007-06-05	$2799.0	$13680
Apple MacBook Pro "Core 2 Duo" 2.6 17" (SR)	2007-11-01	$3049.0	$9752
Apple MacBook Pro "Core 2 Duo" 2.4 15" (08)	2008-02-26	$1999.0	$10058
Apple MacBook Pro "Core 2 Duo" 2.5 15" (08)	2008-02-26	$2499.0	$12574
Apple MacBook Pro "Core 2 Duo" 2.6 15" (08)	2008-02-26	$2749.0	$13832
Apple MacBook Pro "Core 2 Duo" 2.5 17" (08)	2008-02-26	$2799.0	$14084
Apple MacBook Pro "Core 2 Duo" 2.6 17" (08)	2008-02-26	$3049.0	$15342
Apple MacBook Pro "Core 2 Duo" 2.4 15" (Unibody)	2008-10-14	$1999.0	$11515
Apple MacBook Pro "Core 2 Duo" 2.53 15" (Unibody)	2008-10-14	$2499.0	$14395
Apple MacBook Pro "Core 2 Duo" 2.8 15" (Unibody)	2008-10-14	$2799.0	$16123
Apple MacBook Pro "Core 2 Duo" 2.66 17" (Unibody)	2009-01-06	$2799.0	$18040
Apple MacBook Pro "Core 2 Duo" 2.93 17" (Unibody)	2009-01-06	$3099.0	$19974
Apple MacBook Pro "Core 2 Duo" 2.66 15" (Unibody)	2009-03-03	$2499.0	$16954
Apple MacBook Pro "Core 2 Duo" 2.93 15" (Unibody)	2009-03-03	$2799.0	$18989
Apple MacBook Pro "Core 2 Duo" 2.26 13" (SD/FW)	2009-06-08	$1199.0	$4997
Apple MacBook Pro "Core 2 Duo" 2.53 13" (SD/FW)	2009-06-08	$1499.0	$6247
Apple MacBook Pro "Core 2 Duo" 2.53 15" (SD)	2009-06-08	$1699.0	$7081
Apple MacBook Pro "Core 2 Duo" 2.66 15" (SD)	2009-06-08	$1999.0	$8331
Apple MacBook Pro "Core 2 Duo" 2.8 15" (SD)	2009-06-08	$2299.0	$9581
Apple MacBook Pro "Core 2 Duo" 3.06 15" (SD)	2009-06-08	$2599.0	$10832
Apple MacBook Pro "Core 2 Duo" 2.8 17" Mid-2009	2009-06-08	$2499.0	$10415
Apple MacBook Pro "Core 2 Duo" 3.06 17" Mid-2009	2009-06-08	$2799.0	$11665
Apple MacBook Pro "Core 2 Duo" 2.4 13" Mid-2010	2010-04-13	$1199.0	$2965
Apple MacBook Pro "Core 2 Duo" 2.66 13" Mid-2010	2010-04-13	$1499.0	$3707
Apple MacBook Pro "Core i5" 2.4 15" Mid-2010	2010-04-13	$1799.0	$4449
Apple MacBook Pro "Core i5" 2.53 15" Mid-2010	2010-04-13	$1999.0	$4943
Apple MacBook Pro "Core i7" 2.66 15" Mid-2010	2010-04-13	$2199.0	$5438
Apple MacBook Pro "Core i7" 2.8 15" Mid-2010	2010-10-20	$2399.0	$4631
Apple MacBook Pro "Core i5" 2.53 17" Mid-2010	2010-04-13	$2299.0	$5685
Apple MacBook Pro "Core i7" 2.66 17" Mid-2010	2010-04-13	$2499.0	$6180
Apple MacBook Pro "Core i7" 2.8 17" Mid-2010	2010-10-20	$2699.0	$5211
Apple MacBook Pro "Core i5" 2.3 13" Early 2011	2011-02-24	$1199.0	$2096
Apple MacBook Pro "Core i7" 2.7 13" Early 2011	2011-02-24	$1499.0	$2621
Apple MacBook Pro "Core i7" 2.0 15" Early 2011	2011-02-24	$1799.0	$3145
Apple MacBook Pro "Core i7" 2.2 15" Early 2011	2011-02-24	$2199.0	$3845
Apple MacBook Pro "Core i7" 2.3 15" Early 2011	2011-02-24	$2449.0	$4282
Apple MacBook Pro "Core i7" 2.2 17" Early 2011	2011-02-24	$2499.0	$4369
Apple MacBook Pro "Core i7" 2.3 17" Early 2011	2011-02-24	$2749.0	$4806
Apple MacBook Pro "Core i5" 2.4 13" Late 2011	2011-10-24	$1199.0	$1771
Apple MacBook Pro "Core i7" 2.8 13" Late 2011	2011-10-24	$1499.0	$2214
Apple MacBook Pro "Core i7" 2.2 15" Late 2011	2011-10-24	$1799.0	$2658
Apple MacBook Pro "Core i7" 2.4 15" Late 2011	2011-10-24	$2199.0	$3249
Apple MacBook Pro "Core i7" 2.5 15" Late 2011	2011-10-24	$2449.0	$3618
Apple MacBook Pro "Core i7" 2.4 17" Late 2011	2011-10-24	$2499.0	$3692
Apple MacBook Pro "Core i7" 2.5 17" Late 2011	2011-10-24	$2749.0	$4061
Apple MacBook Air "Core 2 Duo" 1.6 13" (Original)	2008-01-15	$1799.0	$6380
Apple MacBook Air "Core 2 Duo" 1.8 13" (Original)	2008-01-15	$3098.0	$10987
Apple MacBook Air "Core 2 Duo" 1.6 13" (NVIDIA)	2008-10-14	$1799.0	$10363
Apple MacBook Air "Core 2 Duo" 1.86 13" (NVIDIA)	2008-10-14	$2499.0	$14395
Apple MacBook Air "Core 2 Duo" 1.86 13" (Mid-09)	2009-06-08	$1499.0	$6247
Apple MacBook Air "Core 2 Duo" 2.13 13" (Mid-09)	2009-06-08	$1799.0	$7498
Apple MacBook Air "Core 2 Duo" 1.4 11" (Late '10)	2010-10-20	$999.0	$1928
Apple MacBook Air "Core 2 Duo" 1.6 11" (Late '10)	2010-10-20	$1299.0	$2508
Apple MacBook Air "Core 2 Duo" 1.86 13" (Late '10)	2010-10-20	$1299.0	$2508
Apple MacBook Air "Core 2 Duo" 2.13 13" (Late '10)	2010-10-20	$1699.0	$3280
Apple MacBook Air "Core i5" 1.6 11" (Mid-2011)	2011-07-20	$999.0	$1548
Apple MacBook Air "Core i7" 1.8 11" (Mid-2011)	2011-07-20	$1349.0	$2090
Apple MacBook Air "Core i5" 1.7 13" (Mid-2011)	2011-07-20	$1299.0	$2012
Apple MacBook Air "Core i7" 1.8 13" (Mid-2011)	2011-07-20	$1699.0	$2632
Apple MacBook Air "Core i5" 1.6 13" (Early 2012)	2012-02-10	$999.0	$1213
Apple iPod (Original/Scroll) 5 GB, 10 GB	2001-10-23	$399.0	$26374
Apple iPod 2nd Gen (Touch Wheel) 5, 10, 20 GB	2002-03-21	$299.0	$14766
Apple iPod 3rd Gen (10/15/30) 10, 15, 30 GB	2003-04-28	$299.0	$25868
Apple iPod 3rd Gen (10/20/40) 10, 20, 40 GB	2003-09-08	$299.0	$15766
Apple iPod 3rd Gen (15/20/40) 15, 20, 40 GB	2004-01-06	$299.0	$16223
Apple iPod 4th Gen (ClickWheel) 20 GB, 40 GB	2004-07-19	$299.0	$11218
Apple iPod U2 Edition (4th Gen) 20 GB	2004-10-26	$349.0	$8722
Apple iPod photo (30) 30 GB	2005-02-23	$349.0	$4742
Apple iPod photo (40/60) 40 GB, 60 GB	2004-10-26	$499.0	$12470
Apple iPod Color Display 20 GB, 60 GB	2005-06-28	$299.0	$4804
Apple iPod U2 Edition (Color) 20 GB	2005-06-28	$329.0	$5286
Apple iPod 5th Gen (with Video) 30 GB, 60 GB	2005-10-12	$299.0	$3639
Apple iPod U2 Edition 5th Gen 30 GB	2006-06-06	$329.0	$3302
Apple iPod 5th Gen - Enhanced 30 GB, 80 GB	2006-09-12	$249.0	$2055
Apple iPod U2 Edition 5th Gen Enhanced 30 GB	2006-09-12	$279.0	$2303
Apple iPod classic ("Original"/6th Gen) 80 GB, 160 GB	2007-09-05	$249.0	$1091
Apple iPod classic (Late 2008/7th Gen) 120 GB, 160 GB	2008-09-09	$249.0	$984
Apple iPod mini 4 GB	2004-01-06	$249.0	$13510
Apple iPod mini (2nd Gen) 4 GB, 6 GB	2005-02-23	$199.0	$2704
Apple iPod nano 1 GB, 2 GB, 4 GB	2005-09-07	$149.0	$1835
Apple iPod nano (2nd Gen) 2 GB, 4 GB, 8 GB	2006-09-12	$149.0	$1229
Apple iPod nano 2nd Gen (RED) 4 GB, 8 GB	2006-10-13	$199.0	$1590
Apple iPod nano (3rd Gen/Fat) 4 GB, 8 GB	2007-09-05	$149.0	$653
Apple iPod nano (4th Gen) 8 GB, 16 GB*	2008-09-09	$149.0	$588
Apple iPod nano (5th Gen/Camera) 8 GB, 16 GB	2009-09-09	$149.0	$521
Apple iPod nano (6th Gen/Multitouch) 8 GB, 16 GB	2010-09-01	$149.0	$356
Apple iPod shuffle (White) 512 MB, 1 GB	2005-01-11	$99.0	$1838
Apple iPod shuffle 2nd Gen (Silver) 1 GB	2006-09-12	$79.0	$652
Apple iPod shuffle 2nd Gen (Colors/Early 2007) 1 GB	2007-01-30	$79.0	$553
Apple iPod shuffle 2nd Gen (Late 2007) 1 GB, 2 GB	2007-09-05	$79.0	$346
Apple iPod shuffle 2nd Gen (Late 2008) 1 GB, 2 GB	2008-09-09	$49.0	$193
Apple iPod shuffle 3rd Gen 4 GB	2009-03-11	$79.0	$511
Apple iPod shuffle 3rd Gen (Colors) 2 GB, 4 GB	2009-09-09	$59.0	$206
Apple iPod shuffle 4th Gen (Wheel/VoiceOver) 2 GB	2010-09-01	$49.0	$117
Apple iPod touch (Original) 8, 16, 32 GB	2007-09-05	$299.0	$1310
Apple iPod touch (2nd Gen) 8, 16, 32 GB	2008-09-09	$229.0	$905
Apple iPod touch (3rd Gen/8 GB) 8 GB	2009-09-09	$199.0	$697
Apple iPod touch (3rd Gen/32 & 64 GB) 32, 64 GB	2009-09-09	$299.0	$1047
Apple iPod touch (4th Gen/FaceTime) 8, 32, 64 GB	2010-09-01	$229.0	$548
Apple iPod touch (4.5/5th Gen/White) 8, 32, 64 GB	2011-10-04	$199.0	$320
Apple TV (Original)	2007-01-09	$299.0	$1936
Apple TV (2nd Generation)	2010-09-01	$99.0	$237
Apple TV (3rd Generation)	2012-03-07	$99.0	$111
Apple iPhone (Original/EDGE) 4, 8, 16 GB	2007-01-09	$499.0	$3231
Apple iPhone 3G 8, 16 GB	2008-06-09	$199.0	$656
Apple iPhone 3GS 8, 16, 32 GB*	2009-06-08	$199.0	$829
Apple iPhone 3G (China/No Wi-Fi) 8 GB	2009-10-30	$0.0	$0
Apple iPhone 3GS (China/No Wi-Fi) 16, 32 GB	2009-10-30	$0.0	$0
Apple iPhone 4 (GSM) 8, 16, 32 GB	2010-06-07	$199.0	$475
Apple iPhone 4 (CDMA/Verizon/Sprint) 8, 16, 32 GB	2011-01-11	$199.0	$349
Apple iPhone 4S 16, 32, 64 GB	2011-10-04	$199.0	$320
Apple iPad Wi-Fi (Original) 16, 32, 64 GB	2010-01-27	$499.0	$1439
Apple iPad Wi-Fi/3G/GPS (Original) 16, 32, 64 GB	2010-01-27	$629.0	$1814
Apple iPad 2 (Wi-Fi Only) 16, 32, 64 GB	2011-03-02	$499.0	$849
Apple iPad 2 (Wi-Fi/GSM/GPS) 16, 32, 64 GB	2011-03-02	$629.0	$1070
Apple iPad 2 (Wi-Fi/CDMA/GPS) 16, 32, 64 GB	2011-03-02	$629.0	$1070
Apple iPad 3rd Gen (Wi-Fi Only) 16, 32, 64 GB	2012-03-07	$499.0	$563
Apple iPad 3rd Gen (Wi-Fi/4G LTE AT&T/GPS) 16, 32, 64 GB	2012-03-07	$629.0	$710
Apple iPad 3rd Gen (Wi-Fi/4G LTE Verizon/GPS) 16, 32, 64 GB	2012-03-07	$629.0	$710

Starfighter

2009-12-23T00:00:00Z

The objective of StarFighter is to fly and blast through asteroids and space debris, making it to the end of the level with a high score. The ship is controlled entirely with the mouse. Lasers are fired by clicking the mouse button. The ship can also launch bombs by holding down the mouse button and releasing it after at least half a second. The longer the mouse button is held down, the further the bomb travels. Bombs are detonated by pressing the space bar.

Features

animation and UI using OpenGL and GLUT
detailed collision detection, optimized using object-aligned bounding boxes/spheres and kd-trees
ray tracing technique used to fire lasers/missiles
gravity-affected, bounce-able projectile simulation with balls
mouse controlled x/y thrust
level input file parsing to construct world, using OBJ output of objects designed in Maya

Libraries Used

Eigen vector/matrix library
kdtree (http://code.google.com/p/kdtree/)
FreeImage for writing images
SOIL (Simple OpenGL Image Library) for texture input

Group:

Long Cheng cs184-cy
Kyle Conroy cs184-cz
Jillian Moore cs184-cx
Wei Yeh cs184-df

Hosted on Github http://github.com/kyleconroy/starfighter

Binary

~~Snow Leopard Only: /data/starfighter~~

Video

Quicktime had some problems. It didn't record the sound effects and created some bad flashing artifacts (seen in the first video)

Images

Compilation

Use make resulting executable is named starfighter

Usage

./starfighter -f levelListFile

Input File Spec

The input file is a level list with pairs

level highScore

separated by newlines. <level>.level refers to the level file in the same directory.

A level file consists of geometry definitions and model definitions.

Level File Spec

Some entries have options [option1 | option2]

Loading a .obj mesh

{
    objgeometry #
    name unique-name # must be a unique name
    path path/to/file # relative path
    bs [box | sphere] # sets the bounding shape, default is box
    boundingsphere x y z r # explicitly sets the bounding sphere
    boundingsphere x y z x y z # explicitly sets the bounding box
}

A sample level file can be found here

Other Credits

Ship model from sender pinarci, on TurboSquid

Asteroid models from Setro on turbo squid

http://www.turbosquid.com/3d-models/free-3ds-model-stones/497091

Sound effects from http://freesound.org

Bezier Curves And The Utah Teapot

2009-11-14T00:00:00Z

My latest CS184 project is now complete and ready for viewing. We had to take in Bezier patches and use tessellation to create triangles using OpenGL. But I know what you really want to see: videos.

CS184 C++ Raytracer

2009-10-10T00:00:00Z

We were tasked with creating a raytracer. Images are followed by the command line which produced them, as well as the scene file describing the setup. All times were calculated using the linux time program. All images on this page were output using my raytracer.

Three spheres and a Triangle

Command:	./raytrace scenes/spherestri.scene
Time:	6.030s
Features:	Reflections, Shadows, Phong Shading, Antialiasing
Comments:	This photo was inspired by the Raytracing Implementation Journal. It shows off shadows quite well
Scene File	spherestri.scene

Five spheres with Reflection

Command:	./raytrace scenes/reflections.scene
Time:	7.714s
Features:	Reflections, Shadows, Phong Shading, Antialiasing
Comments:	This photo was inspired by the Raytracing Implementation Journal
Scene File	reflections.scene

Three Ellipsoids

Command:	./raytrace scenes/mirrors.scene
Time:	32.797s
Features:	Linear Transformations, Reflections, Shadows
Comments:
Scene File	mirrors.scene

Five Ellipsoids

Command:	./raytrace scenes/elipse.scene
Time:	11.506s
Features:	Linear Transformations, Reflections, Shadows
Comments:	This photo was inspired by the Raytracing Implementation Journal
Scene File	elipse.scene

Antialiasing

Resolution	Time	Image
1	0.354s
2	1.067s
3	2.305s
4	4.008s
5	6.093s

Command:	./raytrace scenes/antialias.scene
Features:	Antialiasing
Comments:	The number of rays sent out per pixel is the resolution value squared. As we can see in the first image, we apply a small amount of jitter to each ray, whih further reduces aliasing.
Scene File	antialias.scene

Rendering .obj

Time:	5m45.038s
Command:	./raytrace scenes/teapot.scene
Features:	Loading and rendering .obj files
Comments:	My .obj parser does not support vector normals
Scene File	teapot.scene

Angel

Time:	66m38.493s
Command:	./raytrace scenes/angel.scene
Comments:	Rendering this file is pretty slow without acceleration structures
Scene File	angel.scene