Quite Useful

Christmas eBook Reader Recommendations

Sun, 01 Nov 2009 16:09:00 +0000

This list of ebook reader recommendations on Teleread is interesting food for thought:

“There are no bad readers out there, at least as far as I have seen, so I don’t think you’ll go wrong no matter which one you choose”

I wrote a big introduction to the world of ebooks back in May, and I still generally read on my iPhone. I’m looking forward to testing a Kindle now they’re shipping internationally.

Kev's PSP Money Saving Idea

Sat, 19 Sep 2009 09:50:22 +0100

The PSP is about to go serious on digital distribution with the release of the UMD-less PSP Go. This is great for convenience because you can buy games right from your PSP using the PlayStation Store. However, what’s not great is the price of memory sticks.

Here are the current prices on Amazon.co.uk:

Memory Stick Pro Duo 2 8GB: ~£20

16GB: ~£50

Here are the prices for micro SD cards:

8GB: ~£10

16GB: ~£36

Fortunately you can technically use a micro SD card using an adapter which sells on Amazon for around £4, which is still makes the overall cost less than a memory stick.

I haven’t actually tried this, but shopping around for cheaper 16GB micro SD cards might make it worth it. Micro SD also works with more devices.

Review: Pinboard.in

Sat, 01 Aug 2009 17:16:00 +0100

Pinboard.in is a social bookmarking site by Maciej Cegłowski. Here’s a few things you might like about it:

The interface is incredibly simple and clean
Your huge Delicious library will import quickly without hassle
It has handy bulk processing features
It has bookmarklets that work like Delicious
Gmail-like starred status, and a read later flag
Amazon S3 backups (with some Ma.gnolia mockery)
At a time when Microsoft and Yahoo! are working together, people are looking for serious Delicious alternatives

One big thing that’s unique about Pinboard is this: there’s a one-time signup fee. It’s currently $4.99, and this will scale up as more people join the site. This inspired Cegłowski to dub the site an ”anti-social bookmarking service”.

Imports

If you read this blog you probably already use a social bookmarking service, so the first thing you’ll do is import your bookmarks. Pinboard does this efficiently, firing off a background task that imports items as you use the site.

It retained my Delicious metadata: private bookmarks are still private, tags all appear present and correct.

Design

The interface is inspired by old-skool Delicious, but has its own identity too. It’s unobtrusive and easy to understand.

I think people will like the starred and to read flags. Although tags would do the same job, these flags are much less hassle. Stars are actually used for bulk editing. Viewing starred items (from the top-right navigation) displays a bulk operations box. This makes it easy to tag a set of items, or toggle their starred/to read status.

Bookmarklets

The main “popup” bookmarklet has the same layout as Delicious:

Which is actually nice if you’ve been using Delicious for a few years.

The Fee

I don’t know if the fee is a viable business model, and the developer cites it as a way to cut down spammers and people gaming the site. He’s been careful to select one of the easiest possible payment methods — Amazon — so it won’t put people off.

However, with some grass-roots marketing and enough blog reviews, the developer could easily attract 10,000 signups (I’m speaking from my own experiences of launching commercial web apps here). That would keep him hacking on Pinboard for a year.

I think the ability to gift the service to friends would work well, but that might be against the developer’s anti-social philosophy.

How to Twitter

Wed, 15 Jul 2009 11:09:04 +0100

When Twitter was new a lot of people couldn’t figure out what to use it for. The question What are you Doing? appeared to have no relation to the way popular people used it. It’s an innocuous question that inspired and yet confused people. However, because Twitter is so fundamentally simple — especially compared to other social networks — just about anyone could get started with it and use it for… something.

Now Twitter has cemented its credibility and popularity, people are still wondering what to use it for. As veterans of the service I thought we’d share how we see Twitter used in a meaningful fashion, which will hopefully inspire your own use.

If you like this post, also check out Twitter for your Boss which is a deeper article on helping Twitter gain traction at work.

Retweeting

I’ve seen treatises and manifestos on retweeting. The truth is it doesn’t matter how you do it — if a friend writes an interesting blog post and you share it with a reference to their account name you’re doing them a favour. Just remember to say thanks when people share your links this way.

For Casual Communication and Contacts

The type of people who initially disliked Twitter now seem to use it simple for communication. It’s like a “permanent” IM system. It’s really useful to print your Twitter account name on your business cards to give out at meetups or conferences — I’ve made some useful contacts and friends this way. This is of course the true social networking that services like Twitter promised.

Tips:

Don’t be embarrassed to print your Twitter account name on your business cards
Consider making “casual” business cards for meetups or conferences — moo.com makes this cheap and easy
Get used to checking your @replies so you don’t ignore people

Internet Celebrities

We all know there’s celebrities like Stephen Fry on Twitter. There’s also a lot of Internet celebrities — journalists, programmers, designers, musicians: just about anyone you follow professionally or through a hobby will have an account.

Tips for finding:

Try to discover people through Twitter search or Google — they’ll link to their Twitter account on their blogs or profiles on other sites
Searching for real names can be difficult — a lot of people (especially well-known videogame journalists) use crazy aliases

As an Aggregator

We use our Twitter feed, @quiteuseful to share links to things we think are interesting. There’s a lot of aggregators out there now though, and they’re great if they fit into your interests. Low traffic human curated aggregators like @quiteuseful are like more accessible, compact RSS feeds.

Tips for finding:

Search for hashtags based on your interests
Look for accounts with a topic-focused name, or a name that sounds like a blog
Check out interesting accounts to see if they provide human @replies — steer clear of bots that blindly retweet based on hashtags

Inspirational Books

Mon, 06 Jul 2009 11:50:03 +0100

There’s a war on my shelves between design and programming books. It’s interesting that the programming books look like programming books, whereas the design books are all totally different shapes and sizes. Here’s a few of the design books that I keep close at hand.

A Smile in the Mind

I borrowed this book off a friend and wanted to keep quiet about the fact I still have it, but he’s likely to read this so I’m going to get busted. It’s by Beryl McAlhone and David Stuart, and explains the link between humour and wit and design: the subtitle is “witty thinking in graphic design”.

This book demonstrates through examples and short essays how important wit is to design. It makes it seem so fundamental to design I can’t look at things the same way since reading it.

Show Me the Numbers

Show Me the Numbers by Stephen Few is a slightly technical introduction to the world of presenting tables and graphs. It explains the history and psychology of presenting data, and gives practical advice and solid examples for producing incredible tables and graphs.

The technical background can be dry at times, but it’s watertight. If you ever need to win a design argument with your boss, this book is a gold mine. It’s helped me avoid pie charts time and again!

Paul Arden

I’ve mentioned Paul Arden’s books before on Quite Useful, but It’s Not How Good You Are, It’s How Good You Want To Be is worth mentioning again. On the surface it appears to be yet another self help book, but Arden’s insightfulness, originality and sense of humour makes me keep coming back to it.

Creative Code by John Maeda

If you’ve read my Beautiful Algorithms articles you’ll know I have a fascination with art and code. John Maeda has done a lot to further digital art, and this book is an accessible set of case studies about this area.

iPhone Survival Guide

Mon, 29 Jun 2009 11:48:37 +0100

I’m a first generation iPhone veteran and iPhone developer, and these are my hard-earned tips for you new 3GS users.

Keyboard Tips

Moving the cursor: hold your finger then drag the cursor to move it. You’ll get a magnifying glass effect so you can see it more clearly
Copy and paste: hold the cursor similar to the above, then release it. A pop up menu will display copy and paste options. You can even make a bounding box to copy ranges of text
Correcting mistakes: when you’re new to iPhone typing you’re going to keep hitting the wrong keys. Try leaving your finger on a key and dragging to the correct one before you release it. Also try getting used to trusting the iPhone’s suggestion, they’re generally accurate! Press space to accept a suggestion, or touch the suggestion to ignore it
.?123: You can tap and release “.?123”, or hold it and drag to punctuation. Holding it will cause it to flip back to “ABC”
Currency: Hold down your punctuation currency key to get a list of other currencies (I see £, but holding it shows dollar, yen, etc.)
Domains: When typing in a domain (web site address), you’ll see .com in the keyboard. Hold it to see other common TLDs

Headphones

The standard headphones contain a mic so you can use the iPhone hands-free
The mic bit (the weird white thing) let’s you skip tracks by pressing it twice. Once pauses, three clicks goes back
Pushing it once will let you answer a call or hang up
The new headphones also have volume controls
Removing any type of headphone will pause, which is great for when you arrive at work in the morning (have you ever forgot to pause your iPod and left it playing all day?)

Safari

Tap and hold a link to bring up a menu: open, open in new page, copy
Double tap white space at the top or bottom of a page to quickly move up or down. I prefer swiping up and down to quickly scroll: the speed you swipe affects how far it scrolls
Double tap images to zoom in

Syncing

Be aware that syncing can be slow. This is because iTunes will occasionally backup your iPhone. Factor this in to when you sync: generally syncing will be fast, but if you’ve got a train to catch you can guarantee it’ll do a full sync and backup
Make an iPhone playlist. My 8GB obviously couldn’t store all my music. Therefore, I prefer copying specific music and videos onto my iPhone. I have a playlist with my desert island discs, as well as new purchases and new podcasts
You can sync Yahoo! and Google contacts/calendars/etc with iPhones. Google syncing kind of… messed up my contacts, because of the way Gmail seems to add everyone ever to my contact list. I prefer just syncing with my Mac’s Address Book and iCal, which is standard behaviour

Apps

If you’ve got an Apple TV or Airport speakers, get the Remote app. It’s like living in Star Trek
There’s loads of interesting games, but keep an eye out for original iPhone games that don’t have crazy on-screen joystick interfaces: Flight Control, Peggle

Introduction to Git Part 2: Branches

Fri, 26 Jun 2009 09:26:00 +0100

This is the second part of Ric’s Introduction to Git series. Last time, he covered the basics; this time he’ll explain how to use branches and tags. This article was originally published on Ric’s Blog.

Branches

How Branches Work

In git everything is treated like a branch, so they’re quick and easy to create and manage. Branching doesn’t involve copying the files into a new directory, like in other version control systems. Git keeps track of only the most recent commit to that branch and from there, it can ﬁgure out all the changes in that branch. (The history of changes in git takes the form of a Directed Acyclic Graph).

Branching marks the point that files in the repository diverge onto two different paths. Each branch keeps track of the changes separately. Changes in branches can be merged together later if you like.

In Practice

You can use a branch for anything, but they’re especially useful for keeping experiments or new features separate from bug fixes to already-released code.

Making a New Branch

To make a new branch from the current one, use:

git branch <name of new branch>

If you then run the branch command with no parameters, it will give you a list of all the existing branches (with an asterisk indicating the current one):

> git branch
* master
  my_new_branch

Working with the New Branch

Before the branch can be used it must be checked out. Remember that checkout means something different in git to subversion?

In git, checkout refers to switching the working tree over to using another branch. Don’t worry – any committed changes will safely remain in the branch (even if you’ve not pushed them to your central repository).

git checkout my_new_branch

Pushing the Branch into GitHub

To share the branch, push it to GitHub with this command:

git push <remote_repository> <branch_name>

For example:

git push origin my_new_branch

Getting a Branch from GitHub

What if someone else has made a branch and pushed it up to GitHub already? You can see a list of all the remote branches for a repository with:

git branch -r

Then create a local version of that branch like this:

git branch <name of branch> <remote branch>

Merging Branches

As I mentioned earlier, branches are commonly used as part of a release-process, to keep fixes to ‘live’ code separate from ongoing development. At some point, it’s likely that you’d want to get the bug fixes into the main development branch. This is where merging comes in.

There are three main types of merging:

Straight: Commits are just merged in as they appear in the source branch.
Squashed: All commits from the source branch are applied to the target branch as a single commit.
Cherry picked: A single commit from the source branch can by applied to the target branch.

For all types of merging, commands must be run from the target branch.

Straight Merge

git merge <source branch>

Squashed Merge

git merge --squash <source branch>

Note that for squashed merges, the changes are applied as staged (not committed).

Cherry Picking

git cherry-pick <commit name>

… where the commit name is the SHA-1 hash of the commit you want to pick (or at least, enough characters of it to uniquely identify a commit). You can stage multiple cherry-picked merges by adding the -n argument.

Merge Tracking and Conflicts

Git has automatic merge-tracking that keeps tabs on what commits have been merged together, and so wont merge the same thing twice. Git will also warn you when you try to merge and it can’t resolve merge conflicts automatically.

Introduction to Git

Mon, 22 Jun 2009 10:13:19 +0100

This article is by Quite Useful contributor Ric Roberts.

I’ve been using the version control system, git (along with GitHub) for a couple of months now, for my open source projects: grrid.js and Taskit. At Swirrl, we recently decided to take the plunge to start using git for our main code repository.

With this series of blog posts, I hope to ease the transition from subversion (or sourcesafe, or whatever) to git. In this article, I’ll just cover the basics. More advanced stuff will come later.

Why Switch?

There are several advantages to using git over other version control systems:

Being a distributed version control system, everyone has their own version of the whole repository. The central repository (at GitHub in my case) is just arbitrary. This means that you can do operations such as tagging, branching and diff without having to be connected to the central server. This article by Eric Sink is a good explanation of how git differs from traditional version control.
Due to the git:// protocol and the way git stores and tracks the data and changes in repositories, it’s really fast and the repositories don’t take up much room on disk.
Quick, cheap, easy branching.
The repository and branches are separate from the filesystem.
GitHub. Why go to the trouble of hosting a central repository yourself, when you can do it securely, cheaply and quickly with GitHub? There’s Sourceforge for svn, but for me GitHub does it better. If you can get to grips with GitHub, it opens up a world of possibilities for publishing or consuming open source code.

How Git Works

The whole repository is stored in a hidden folder called .git at the top level of your project structure. The working tree — the actual files in your project — are just the ones you happen to be working with at the time. Git doesn’t track the files themselves, it just tracks their content along with some metadata (read more about this here).

Git stores content in these locations:

The working tree. This is the file system, where you manually make the changes.
The staging area, where changes lie until they’re committed.
The repository itself, where committed changes go (you can have local and remote repositories).

Commits in git are labeled with an SHA-1 hash instead of version numbers. There’s a very small chance of the hashes ever colliding, so they can be assumed to be unique. Git actually generates a 40 character-long hash but normally the first 7 or 8 characters are enough to uniquely identify a commit.

Installing Git

If you’re using Mac OS X like me, the easiest way to install git is to download the installer from the Google Code project. I used version 1.6.2.2. Alternatively, you can compile it from source or use Macports (see this guide).

If you want to share your code with others, you will need a centrally accessible server. GitHub provides this service for free.

Setting Up a Repository

Sign Up for GitHub

Visit GitHub and sign up for an account.

Next, set up an SSH key. This allows the git command to authenticate with GitHub and send your code to their servers.

Next, configure the global parameters on your computer to tell git what your GitHub username and email address are. For example:

git config --global user.name "RicSwirrl"
git config --global user.email my.email@address.com

Getting Code Into GitHub

Make a new repository with the GitHub web interface. Creating a new repository on GitHub gives you a short guide so you don’t need to remember all the steps. The process is outlined here for completeness.

Initialise your local project by changing into its directory and running:

git init

This will create the .git folder. Next, tell git about the GitHub remote (get the full command from the GitHub web interface):

git remote add origin ...

Next, add all the files in the directory to the repository. At this point they’re not being tracked yet.

git add .

This will add all the files in the directory to the staging area. You can then commit these files to your local repository, with a message:

git commit -m "my initial commit"

Now you have a fully fledged repository on your computer. To send it up to GitHub, just run:

git push origin master

Note that by default git will push to the “origin” remote repository in your config, using the current branch. If you want to push to a different remote repository, using a different branch, you can run something like:

git push github mybranch

Note: for this to work you’d have to define github in your config file as another remote repo, and have a ‘mybranch’ branch.

Push is a similar to a subversion commit, in that it allows you to share your changes with your colleagues.

Working With Existing Repositories

What if one of your colleagues has already set up the repository on GitHub? To get started, you just need to clone the remote repository like this (using the clone url displayed on the GitHub page). For example:

git clone git://github.com/Swirrl/grrid.git

I suppose this is equivalent to a subversion checkout. Watch out, though, because checkout means something a bit different in git.

Working With the Repository

Adding Files to the Staging Area

You’re now ready to start making changes to your code. Once you’ve made a few changes, you can see what’s happened by running:

git status

If you’re ready to commit some of these changes to your local repository, you need to run git add on each file you want to commit. This adds these changes to the staging area.

git add <filename_to_add>

What’s the Point of the Staging Area?

The staging area lets you choose which of your changes you want to commit – a bit like checking/unchecking files in the svn commit dialog in TextMate (or your editor of choice). You can change the files in your staging area as many times as you like, before committing.

Committing to the Local Repository

You can run git status again to check what’s going to be committed. When you’re happy, run:

git commit -m "my message"

…and the changes will be committed. If you know you just want to commit all the changes that you’ve made, you can do it all in one go by running this (i.e. skip the staging step):

git commit -a -m "my message"

Pushing Changes to the Remote Repository

At this point, the changes have been committed to your local repository, but the remote GitHub repository remains unchanged. For your colleagues to be able to see your commits you need to push them up to the remote repository with:

git push

Pulling Changes From the Remote Repository

If you want to see what your buddies have been up to, you need to pull their changes from the remote repository.

git pull

This will fetch the remote changes and merge them with your local ones — it’s a bit like the update command in subversion.

Viewing the Log

To see the history of the commits in a repository:

git log

Getting Help

Many git commands can take multiple optional arguments which I haven’t covered here. To get help on the usage of any command you can do:

git help <command>

Review: MinuteBase

Fri, 12 Jun 2009 16:22:00 +0100

MinuteBase is a web application designed for planning meetings and writing up minutes. It helps focus meetings with an agenda, and provides lots of ways of collecting notes and other related information.

Each meeting can have several attendees, and they can be added as users to your MinuteBase account. This makes MinuteBase a good tool for communicating agendas before meetings to help keep discussions focused. Attendees can also see minutes (which have privacy controls), so meetings can be followed up with relevant actions. Minutes can also accept comments for later discussion.

Text, actions, files, links and agendas can be appended to each agenda item. This makes MinuteBase a good central location for information produced during a meeting.

Design

There’s some great attention to detail in MinuteBase’s design. It also uses a lot of white space, so pages feel clean and easy to understand.

Here’s what the dashboard page looks like when you sign in:

The dashboard makes it easy to add a new meeting and see existing ones. It also has some useful inline documentation:

I particularly like the search widget:

Minutes can be displayed in view or edit modes. The edit mode has intuitive hover effects which make it easy to insert items at any position, or edit existing items:

The PDF export for minutes is also excellent.

Conclusions and Pricing

I’ve had many meetings where internal systems were used to collect data, which is difficult to access outside of the office unless you can use a VPN. MinuteBase would be perfect for teams collaborating across different companies or departments. It would also help in meetings where attendees are known to stray off-topic and overrun the allocated meeting time.

The only other things I’d like to see in MinuteBase are meeting timers and audio clips. Most people find it hard to keep meetings on time, so it would be useful to have timers for each agenda item. Additionally, although people have dedicated tools for recording audio in meetings, MinuteBase might appeal to certain corporate customers if it did that too.

Another thought I had was using MinuteBase for organising conference calls. These can be awkward when working across company boundaries, so collecting attendees’ voip or telephone details inside MinuteBase would make a lot of sense.

The pricing varies between £10 and £50 a month, which seems like sensible pricing considering the types of customers who will use MinuteBase.

Review: Ringer

Thu, 11 Jun 2009 19:58:00 +0100

Ringer is a small Mac app made by Pixel Research Labs that helps you create ring tones for iPhones. It’ll read any unprotected audio or video file.

It automatically adds a quick fade in and out, so tracks will sound right without much effort. You can change the length of the snippet you want, and add a gap between rings. Ringer automatically detects the volume too, so quiet or loud songs should still be effective ringtones.

Working with files looks like this:

Your iTunes media library is presented to you, and searching through a large collection is fast.

Garage Band can also be used to create ringtones, but Ringer is much easier, and it’s an incredibly well-crafted app to boot. A licensed version will cost $15.

Review: Figure Out When

Tue, 02 Jun 2009 12:25:17 +0100

Figureoutwhen.com is a tiny service for organising dates. It works like this:

Enter a title for an event
Click the dates you’re not available
Send the link to friends you want to invite
They click the dates when they aren’t available

Everyone can see when they’re not free, thus allowing you to figure out when to schedule an event.

It’s an incredibly simple tool, but has a clever “just works” interface, there’s no registration, login, saving data… just a simple calendar and title for your event. Figure Out When works best when organising an event in the near future, because the month defaults to the current month (rather than the last one selected).

The only thing I’d like to see added is shift-clicking to select date ranges. This might help people when organising events that could happen any time in a month.

JsChat

Thu, 28 May 2009 10:51:48 +0100

JsChat is a simple open source realtime chat protocol based on JSON. There’s a server and console and web clients. It’s developed by the Quite Useful authors. Download it from my GitHub repository: github.com/alexyoung/jschat, and read more at the JsChat Blog.

Web Client

Most people who have tried JsChat think it’s all about the web client, but this is only a proof of concept I built to illustrate how simple implementing the JSON-based protocol can be. It’s made with Ruby and Sinatra (Sinatra is a tiny Ruby web framework).

It has a few interesting features:

YouTube URLs are automatically embedded so people can watch them
Image URLs are embedded too
Tab completion for names
Joining a room gives you the last 100 lines, so you can safely leave and come back
Rooms are just denoted by a hash part in the URL: jschat.org/chat/#jschat
It’s possible to open multiple tabs in your browser and sit in multiple rooms
It polls using simple Ajax calls which means it’ll run in lots of browsers (I’ll experiment with detecting browser-specific push capabilities in the future)

Console Client

The console client is written with Ruby and Ncurses. You can connect to JsChat.org by downloading it and running:

./client.rb jschat.org

It’ll pick up your name from the system and auto-join #jschat. You can join multiple rooms and switch between them using /switch (or /s). Type /help for more commands.

I’m not particularly good at Ncurses, so I’m waiting for someone to help clean it up!

Running Your Own Server

I’m going to blog more about how to run the web app alongside the core server with Apache and mod_proxy, with strategies for keeping them running (I’ll start with monit examples).

If you’d like to try it locally, just run:

./server.rb

./client.rb

Authors

Protocol creation and initial server, client and web app: Alex Young (message me on GitHub or @alex_young for more info about JsChat)

Initial concept, testing, feature suggestions: Kevin Ford

Bug fixes and code contributions: Simon Starr, Ric Roberts, Nick Martini, Jenf

JavaScript sanity checker: gabrielg

Beautiful Algorithms 3: Gravity

Wed, 20 May 2009 09:26:00 +0100

This series of articles explores using basic physics and mathematics to simulate balls bouncing. The examples are written with Ruby and Shoes.

I’ve been working on the 2D version of the previous example for 3 days now, and I haven’t got it to a point where it’s clear enough yet. However, I realised I was trying to cram too much into one article. Instead, this part focuses on explaining vectors, and simulating gravity. Although simulating gravity is simple for this simulation, I think you’ll be surprised by how naturally the balls bounce.

Vectors and Vectors in Ruby

A vector is just a direction of a force. They’re usually drawn as a line with a direction. More generally, vectors are quantities that are made up of components. In the previous article, arrays were used to represent direction and velocity. This is adequate, but not as natural as vectors when used with mathematical operators:

[1, 2] + [8, 2]

=> [1, 2, 8, 2]

If you’re used to mathematics, this result might surprise you. What we want is:

[9, 4]

However, the + operator in Ruby treats arrays like sets and concatenates them. This is generally the most intuitive thing to do. What we need is a way of defining vectors.

Vectors are essentially matrices, and Ruby has a matrix library in its standard library. Vectors are defined like this: Vector.[](1, 2) and can be added, multiplied, and more:

require 'matrix'

v1 = Vector.[](1, 2)

=> Vector[1, 2]

v2 = Vector.[](8, 2)

=> Vector[8, 2]

v1 * -1

=> Vector[-1, -2]

v1 - v2

=> Vector[-7, 0]

v1 + v2

=> Vector[9, 4]

v2 * 0.1

=> Vector[0.8, 0.2]

v2.r

=> 8.24621125123532

v2.inner_product v2

=> 68

Advantages

This makes the code in the previous example clearer, because inverting velocities and updating position becomes much clearer:

@position += @velocity * @mass

@velocity = ((@velocity * -1) * @eta)

These expressions update both the X and Y values for the position and velocity. The second will be used to simulate bounces off the wall.

Gravity

To model gravity, the Y component of the velocity vector will be updated for each frame of animation:

@velocity += Vector.[](0, @gravity)

This looks suspiciously like it will result in infinite speed, but because the overall space the ball can move in is so small we can ignore this for now.

Wall Bounces

I’ve been very explicit about detecting bounces against the “walls” of the scene. Each wall is checked (because the ball could hit two at the same time), and if a bounce has occurred the ball is moved back to the wall. This is in case it bounces through the wall in cases where it’s moving very fast. The bounce_off_wall method just uses the velocity vector multiplication described above.

    if @position[0] >= @app.width - (@radius * 2)
      @position = Vector.[](@app.width - (@radius * 2), @position[1])
      bounce_off_wall
    end

Scene Management and Keyboard Commands

My example adds some methods for creating random balls with different velocities and mass, and it also adds keyboard commands for reset (r) and adding a new ball (a).

Putting it Together

Get ball-gravity.rb from my GitHub repository shoes-ball and run it with Shoes.

Quite Useful Weekly Roundup

Sun, 17 May 2009 12:46:45 +0100

This week we posted the first of a new series of Beautiful Algorithms articles: Collisions. We also posted about eBooks and a web app called Orchestrate.

Twitter Summary

TeleRead is a great blog about eBooks. They post regularly, and write about hardware readers, formats, sites that sell/host eBooks.

6 Tips To Get Your App Noticed has some ideas for marketing your iPhone apps.

Wiimote Whiteboard is an open source project for using Wiimotes to turn any surface into an interactive whiteboard.

Windosill is an incredibly imaginative Flash puzzle game.

App Reviews

Please send us links to your web/iPhone/Mac/Windows apps so we can review them!

Beautiful Algorithms 3: 1D Collisions

Fri, 15 May 2009 11:10:06 +0100

“1D Collisions” might sound a little bit strange, but the goal of Beautiful Algorithms 3 is to explore algorithms for collision physics. Collisions in 2 or 3 dimensions are naturally more complex than a single dimension, so let’s look at this first. I’ll explain what mathematics and physical laws are required (don’t worry, you understood all of this when you were 13), and then explain how to write a Ruby program to simulate this.

Newton’s Laws

You probably did simple experiments in science classes at school whereby objects were rolled down ramps, and their bounces were measured. This is a physical exploration of Newton’s second and third laws of motion.

Newton’s second law of motion: Momentum = mass * velocity
Newton’s third law of motion: For every force there is an equal and opposite force
Newton’s law of impact: The difference between velocities before impact is proportional to the difference between their velocities after impact

In the Ruby Shoes example, we’ll draw two balls and make them collide. Calculating their position for a given frame of animation will require the second law. Collisions will use the third law and law of impact to calculate the velocities after impact.

Velocity

Velocity is the rate of change of position: speed and direction are combined as a vector. Vectors aren’t scary — in this example we’ll use an array to model velocity for the speed going left or right and up or down.

The velocity will change after impacts according to the second law of impact and third law: that is, the velocity should be reversed after impact, transferring some of its energy in the process.

Required Variables

According to the brief and possibly inaccurate summary of high school Newtonian physics above, each ball will have the following variables:

Mass
Velocity (as an array) — negative values will mean left or up
X and Y co-ordinates
A value for the coefficient of restitution — basically the amount of energy lost in each impact

Required Methods

We’ll need to know when balls bounce off each other or the walls of the scene. We’ll also want to update the position for each frame of animation.

check_collisions(set of balls)
hit?(ball) — check if the ball has bounced off another one
collide — if a collision has been detected, alter the velocity according to the laws above
move — move the ball

Collision Detection

The algorithm works like this:

Calculate the distance between two balls using Pythagoras’ Theorem by subtracting their positions to create a common frame of reference, then calculating the hypotenuse
If this value is less than or equal to the combined radius of each ball, they’ve bounced
If the ball has moved to the end of the window, it has bounced

The first step sounds a little bit complicated. Basically:

x = absolute value of: ball_a.x - ball_b.x - x_velocity
y = absolute value of: ball_a.y - ball_b.y - y_velocity
hypotenuse = square root of (x squared + y squared)

Main Loop

The main loop will look like this (example requires JavaScript to display):

Putting it Together

The final example is available here: ball-1D.rb. You can run it with Shoes. Note that there’s no friction or gravity, bodies simply bounce until their collisions reduce their velocity enough.

Try playing around with the velocity and mass settings to see what happens. I’ll be back on Monday with a 2D collision example!

Beautiful Algorithms 3: Balls

Thu, 14 May 2009 13:23:00 +0100

Beautiful Algorithms 3 is going to be about simple physics. These examples will be written with Ruby Shoes, and will demonstrate how to simulate bouncing balls and collisions.

The easiest way to model bouncing is to go back to basics with high school physics. Start off with 1D collisions, then add the second dimensions, then apply gravity.

The first post in this series will be posted tomorrow. To get Shoes, download it here: shoooes.net. My previous Shoes example was Let’s Make a Game: Snake.

eBooks

Tue, 12 May 2009 11:59:29 +0100

You’ve probably seen the Kindle, Amazon’s reading device. I live in the UK, and I have massive Kindle envy because Amazon don’t sell it outside of the US. That doesn’t mean we all need to wait for Amazon to launch localised Kindles, however. eBooks have been with us for a long time: Project Gutenberg’s founder Michael Hart has been exploring eBooks since 1971. I used to read books on my Palm IIIe at university to save money. The old Palm’s low-glare monochrome screen was good for reading, and I was happy with it.

Since my experience with eBooks on Palm I’ve tried many devices. I’m currently using an iPhone with the Stanza app. There’s a few things I like about Stanza: it’s easy to change the brightness by dragging across the screen, there’s a lot of options for fonts and sizes, and page changes are fast. In terms of comfort, however, reading on the iPhone isn’t optimum. It’s equivalent to my old Palm but I imagine the Kindle or Sony Reader offer better experiences.

Content and Formats

The main problem with eBooks right now is finding content. This is a solved problem is you’re using a Kindle in the US, and Sony has their own store too. Sony’s device can use books from other sources too. If you’re not using one of these devices, it’s not always clear what books will work for you: some online shops don’t display their formats known. Others specifically note the format and DRM used. And even when they display formats, what do they mean and what can your reader support? If you’re using Stanza and you buy a DRM’d ePub, will it work? (The answer is: not currently).

Sony’s products support DRM, most notably for ePub. If you buy a book in the DRM’d ePub format, Adobe’s Digital Editions will open it and manage the DRM. Interestingly, ePub is basically a load of XHTML, so it’s an easy format for developers to support.

Another popular format is .mobi (or Mobipocket), which is an extension of the PalmDOC format. It can be DRM’d. As far as I know, this doesn’t work on the Sony Reader, but it could be converted, and the Kindle does support it.

You’ll probably also come across LIT. Microsoft Reader will open these files, which is on PocketPC and Windows Mobile devices. Stanza’s desktop app allows me to open LIT files and send them to my iPhone; I think the Sony Reader will need the files converted.

There are many other popular formats. Books are distributed in RTF, plain text and PDF, and the frightening list here contains more. Generally, if you’re sent a LIT, ePub or mobi file, it’ll work well on a hardware reader (or with minimal conversion through desktop software). I’ve had a lot of luck with ePub and LIT with Stanza and iPhone. PDF has been a problem: yes, I can read them, but they just don’t work very well on hardware readers. Plain text and RTF can lose some of the elegance of a well presented LIT or ePub book.

Converting Files

You’ll be converting formats a lot. Calibre works well, and Stanza’s desktop app will try to adapt content for your iPhone. Calibre will run on Windows, Mac OS and Linux.

Yes, you can strip ePub DRM. The process is quite technical, and will become more difficult when Adobe fixes a security flaw in Adobe Digital Editions. It may be illegal in your country to do this.

Finding eBooks

I can only list sites I’ve had luck with, and my list is generally UK-centric. Stanza has a built-in list of sources as well.

Fictionwise - US-based, but has a lot of content. I haven’t bought anything form here, but they’re clear about formats and DRM.
WHSmith eBook Shop - very clear about DRM, but mix in audiobooks with results so keep an eye on the format you’re purchasing.
Waterstones - heavily promoted the Sony Reader in the UK. Not clear enough about DRM and formats, but the books I’ve got from there have been ePub DRM’d and open on my Mac and PC with Digital Editions. Their advanced search lets you limit results to eBooks, but this sometimes decides to include regular books.
Penguin - Similar to Waterstones, selling DRM’d ePub
Pragmatic Programmers - the template for all future eBook sites. Once you buy a book you can download multiple copies in PDF, ePub and mobi with no DRM. Only really suitable for software and designer folks, but if all eBook sites were done this way life would be simple.
O’Reilly - Also sell un-DRM’d eBooks that’ll work on just about any device.
Project Gutenberg - Copyright expired books

Blogs

ePub Books
TeleRead - the best blog about eBooks

Conclusions

I hope this article has clarified the world of eBooks. At first all the formats and DRM are hugely frustrating, but the growing dominance of .mobi and ePub should make things simpler, and publishers who support DRM-free books will ultimately create a world where anyone can understand and use eBooks.

Web App Review: Orchestrate

Mon, 11 May 2009 09:45:16 +0100

Orchestrate is a web application made by Elevensoft, who are based in the UK. It’s designed to manage tasks for projects. What makes it unique is the focus on scheduling conflicts and qualification management.

Orchestrate has a clean interface, similar to Lighthouse or Basecamp: the main page body is used to display information and forms, whilst the sidebar is used to issue commands or change the view. It also has a prominent breadcrumb navigation, so it’s easy to jump back to earlier stages of a process.

The only tweak I’d like to see here is automatic field focus: I’m used to web apps putting careful thought into what field I’ll need to type in on a freshly loaded page.

Scheduling

Tasks can be assigned to locations and people. It’s also easy to set up recurring tasks, then assign them to people based on a weekly schedule overview. You can then see all of the events for a particular day in a summary by clicking on the day:

Qualifications can be created and assigned to people. This makes it easier to decide who can perform a particular task. This makes sense: in our company I’m the only person who can deploy apps to our servers, so I’d set that up as a qualification. Other tasks like writing blog posts are accessible to more than one of us.

Once a task is ready to be signed off, there’s a set of standard outcomes that can be selected:

Pricing and Conclusions

There’s a free plan, and other plans start at $19 per month. All paid plans give unlimited users so they’re pretty good value, and the top plan at $199 per month gives branding features. Judging by customer feedback I expect branding will be dropped to other plans, but this will probably be determined by how many companies pick up the $199 plan.

The Help page is powered by Get Satisfication. I’d much rather see a comprehensive help page with usage examples; despite Orchestrate consistently claiming to be easy to use and simple, it took me too long to figure out its terminology and features. The interface is always clear and also provides inline help tips, but more detailed inline help would really get people going with less initial confusion.

I use project management software: I’ve used Basecamp since it was launched, and I still use it to manage client projects today. The core feature that makes me stick with Basecamp is messaging, and Orchestrate doesn’t do this. However, many business people I’ve worked with have wanted more sophisticated scheduling like Orchestrate offers, and it does provide client updates, so it may work better than Basecamp for companies who want this type of scheduling.

Quite Useful Weekly Roundup

Sun, 10 May 2009 12:47:47 +0100

This week we posted a selection of command line time savers, the source code for a Ruby Twitter scheduler, and a review of online collaboration service Woobius.

Twitter

I was having a bit of fun with mashups this week, so I posted a link to DJ Lobsterdust who makes some incredibly witty and skilled tracks. If you like that, it’s worth checking out Girl Talk too.

A lot of Twitter/Digg style sites were announced this week: Daily RT and Twittl were heavily linked to. Although these types of sites don’t seem wildly popular right now, their obviousness is leading some people to believe Twitter’s future will be based on reputation: a combination of Google’s PageRank with social networks.

On the Mac apps side, I found Warranty Hero which is an interesting app: it aims to help you track when you purchased items along with their receipts. Page Capture also seemed to strike a chord, I’ve been using Paparazzi! for a few years to do the same thing — great apps for designers building images for a portfolio or for clients.

I posted a few developer links, but one that stood out was an OCUnit tutorial. I’ve been a Ruby programmer for several years, where unit testing is part of a day’s work. In the Objective-C (iPhone/Mac) camp, however, unit testing isn’t part of the scenery. It’s worth getting to grips with OCUnit though, if only to save your sanity in the long run!

Mind Blowing Command Line Time Savers

Fri, 08 May 2009 11:20:27 +0100

Whether you’re an old skool unix hacker or a Mac user who uses Terminal regularly, there’s lots of ways to save time on the command line. I’ve mentioned a few of the following tips on twitter.com/quiteuseful, but I thought it’d be handy to collect them all here.

Bash

!! - repeats the last command

history n - shows the last n things you’ve typed

My favourite shortcut is ctrl-r: this lets you search through history interactively. I probably use ctrl-r every day, I really don’t like repeating myself!

xargs is a useful command: it’ll construct argument lists. It works really well with pipes:

find *.rb | xargs grep -i "ActiveRecord"

Aliases

My aliases end up getting ridiculously short. I don’t ssh into my screen session with IRC, etc, I just type “irc”. I don’t even type ls either:

alias l='ls -Gla'

If you’re on a Mac you should have a ~/.profile file, so you can add aliases there.

Apps: ack and cdargs

My two favourite command line time savers are ack and cdargs. I found myself searching code a lot, and ack works better than grep for this. It’s also useful for finding documentation: why view the Rails HTML docs when you can ack the Rails source? Give it a go with one of your regularly used libraries!

You can get ack from betterthangrep.com.

cdargs lets you bookmark directories, then cd to them with a shorter name. I have a lot of code in ~/Documents/Code/project_name, and I move between projects every day. I bookmarked these with ca, then I cd to them with cv project-short-name.

You can get cdargs here: cdargs.

These apps don’t sound like a big deal, but they really help me switch between projects. Ack is great for navigating code too: you can get plugins for TextMate or Vim.

Quite Useful

Christmas eBook Reader Recommendations

Kev's PSP Money Saving Idea

Review: Pinboard.in

Imports

Design

Bookmarklets

The Fee

How to Twitter

Retweeting

For Casual Communication and Contacts

Internet Celebrities

As an Aggregator

Inspirational Books

A Smile in the Mind

Show Me the Numbers

Paul Arden

Creative Code by John Maeda

iPhone Survival Guide

Keyboard Tips

Headphones

Safari

Syncing

Apps

Introduction to Git Part 2: Branches

Branches

How Branches Work

In Practice

Making a New Branch

Working with the New Branch

Pushing the Branch into GitHub

Getting a Branch from GitHub

Merging Branches

Straight Merge

Squashed Merge

Cherry Picking

Merge Tracking and Conflicts

Tags

When to Use Tags

Introduction to Git

Why Switch?

How Git Works

Installing Git

Setting Up a Repository

Sign Up for GitHub

Getting Code Into GitHub

Working With Existing Repositories

Working With the Repository

Adding Files to the Staging Area

What’s the Point of the Staging Area?

Committing to the Local Repository

Pushing Changes to the Remote Repository

Pulling Changes From the Remote Repository

Viewing the Log

Getting Help

Review: MinuteBase

Design

Conclusions and Pricing

Review: Ringer

Review: Figure Out When

JsChat

Web Client

Console Client

Running Your Own Server

Authors

Beautiful Algorithms 3: Gravity

Vectors and Vectors in Ruby

Advantages

Gravity

Wall Bounces

Scene Management and Keyboard Commands

Putting it Together

Quite Useful Weekly Roundup

Twitter Summary

App Reviews

Beautiful Algorithms 3: 1D Collisions

Newton’s Laws

Velocity

Required Variables

Required Methods