Review: Woobius

Woobius is a web app aimed at architects and engineers, designed to enable them to collaborate online.  The main features are:

• Drop box - Quickly share files with colleagues
• Vault - Manage formal documents, track changes to them, and issue documents to colleagues with an expiration date
• Companies - Give your clients access
• Dashboard - Get an overview of activity

Workflow

The workflow within Woobius has been designed to work well for people in the architecture and engineering industries.  Although I don’t work in these industries, the processes were familiar as a freelancer and consultant.

The vault offers a full audit trail for both changes and downloads.  Knowing when clients have downloaded documents is very useful — especially if you issue a redesign and they don’t give feedback until the sign-off date.

Interface

The interface is a sophisticated Flex app.  It doesn’t feel too flash-heavy, it feels light and web-native.  People from the targeted industries will feel comfortable using it.

Woobius is very good at providing content for “empty pages” — when you initially access it there’s a healthy amount of inline help and help popups.

Detailed help popups complete with screenshots appear the first time a feature is accessed.  This is great for the Vault, where the usage is deeper than other areas of the app:

Pricing

Woobius pricing is based on storage.  You can try it out for free, or pay £10/GB per month, with an initial £10 setup fee.  This makes it incredible value for money.

Twitter Scheduler

In Delicious Twitter Sync I talked about one of the open source tools we use to run Quite Useful.  Another script I’ve written to help out is twitter-scheduler.  This one allows you to schedule tweets on the command line.

I use this to schedule up interesting tweets so they’re evenly distributed throughout the day.  We try to post on the hour between around GMT 10am and 7pm.

Usage

To use the script, run it with your Twitter username and password:

./scheduler.rb -u quiteuseful -p password

And leave that running.  In another terminal, schedule up tweets like this:

./scheduler.rb -a 11am -t "This will be sent at 11am"

Deleting tweets is also possible.  An ID is returned when a tweet is scheduled, and can be used with -d:

./scheduler.rb -d 33

Calling the script with -l will list the scheduled tweets.

Libraries

This script is written in Ruby and uses OpenWFE to schedule jobs.  It also uses Chronic to parse human-readable dates.  Both these libraries are easy to use and integrate with your own scripts.

Delicious Twitter Sync

Quite Useful has a Delicious account which we use to share links we post to twitter.com/quiteuseful.  I wanted to sync up our Twitter link posts with Delicious, so I wrote a script to do the job.

The script will download a Twitter account’s recent posts, find links, and tag links based on hashtags — which is why our Twitter posts almost always have a generous helping of hashtags.

Running the twitter2delicious script with --help will show the available options:

Usage: ./twitter2delicious.rb [options]
    -d, --delicious=username         Your Delicious username
    -p, --password=password          Your Delicious password
    -t, --twitter=username           Your Twitter username
    -H, --help                       This text

It can also be run interactively, where it will prompt for usernames and passwords.

You can get the script from here: twitter2delicious.  It’s a ruby script and requires a few gems to get going, so you may need to install rdelicious, simple-rss and hpricot.

If you like the script or have any ideas for it, message me on GitHub! (I’m alexyoung on there).

Code Notes

Twitter’s search API includes hashtags as links.  Of course, you don’t want to post these to Twitter, so the script will filter them.  However, it also escapes the hashtags, so it filters like this:

url.match(/\/search\?q=#/) or url.match(/\/search\?q=%23/))

The Delicious API doesn’t mind if you post the same link twice, so I’ve taken the easy option and ignored this.  I run the script once a day (you could actually cron it), and it silently ignores reposted links reliably.

It also tries to follow tinyurl links to get the link’s real title.  It doesn’t include the original tweet in the Delicious post description in case it doesn’t make sense — we write tweets in this format: “an interesting link: http://example.com #tags” which doesn’t translate into a Delicious description very well.

Quite Useful Weekly Roundup

This week we featured a Beautiful Algorithms series: Tunnels Part 1, Part 2.  The rubyisation of the demoscene continues!  I also wrote about how to build a Growl app in Objective-C for Mac OS.

Useful Tweets

RemotePad for iPhone is an open source computer controller.  Interesting for iPhone developers, but useful too.

Canary is an open source Mac Twitter client.

TwitterSnooze lets you quieten down noisy friends.  Part of your anti-social social network toolkit!

Aviary, the web-based image software, now has an API.

Another one for developers: Jamis Buck open sourced his BucketWise accounting software.  It has an interesting take on accounting, where “buckets” are used to partition funds across accounts and cards.

How to Make a Growl App

I made a little Objective-C growl app the other day (Deadline for Mac).  It started as an idea I had on Saturday afternoon, and ended up being a finished product by Sunday night.  Working with Growl is surprisingly simple!

This is a short tutorial on how to build your own Mac app that uses Growl.  You’ll need Apple’s developer tools installed and some familiarity with Xcode.  It’s an interesting exercise even if you’re not too savvy with Objective-C, so give it a go and let me know what you make.

Getting Started

Growl needs a few things before you can get started:

• An app that includes a Growl Registration Ticket.growlRegDict
• The Growl framework.  Download it here: Growl Developer Downloads

Create a new project in Xcode and call it GrowlExample.

Copying the Framework into Your Project

Download and unpack the Growl SDK.  Copy the Frameworks directory somewhere (you can delete it later, I just dumped it on my desktop).

Right-click a suitable group (Frameworks) in Xcode and select Add… Existing Frameworks.  Select Growl-WithInstaller.framework.  Make sure you check Copy items into destination group’s folder.

Next you need to tell Xcode to copy this file into your application’s bundle.  Expand the Targets group, right-click GrowlExample and select: Add… New Build Phase… New Copy Files Build Phase.  Drag the Growl-WithInstaller.framework file into this build phase.

Right-click the Copy Files build phase, select Get Into, and change Destination to Frameworks.

Informing Growl About Your App

Every Growl-based app needs a Growl Registration Ticket.growlRegDict file.  Create a new file in Xcode and select Other… Empty File.  Name the file Growl Registration Ticket.growlRegDict.

You’ll need to paste some XML into this file.  The format is simple but it’s way easier to paste it than explain it.

Here’s the XML as a Gist (if this isn’t visible, load this page up in a browser):

Save the file and drag it to the Copy Bundle Resources build phase.

Create an App Delegate

Since this isn’t a real app you’ll need an example class to create some growls alerts.  Add a new file, select Mac OS X… Cocoa… Objective-C class.  Name it GrowlExample_AppDelegate.

Next, let’s link this up in Interface Builder:

1. Expand the XIB Files group in Xcode
2. Double-click MainMenu.xib
3. Add an Object from Library
4. Edit the object’s identity and set the class to GrowlExample_AppDelegate
5. Ctrl-click File’s Owner, drag a link to GrowlExample_AppDelegate object to make it the delegate

Using Growl in Your Code

Open GrowlExample_AppDelegate.h in Xcode.  Change the @interface line like this:

GrowlExample_AppDelegate.h: @interface GrowlExample_AppDelegate : NSObject <GrowlApplicationBridgeDelegate> {

And include Growl.h at the top of the file:

#import <Growl/Growl.h>

Sending growl messages is as simple as calling [GrowlApplicationBridge notifyWithTitle]:

Final Example

I’ve put my Xcode project on GitHub so you can download the full example: growlexample

Beautiful Algorithms 2: Tunnels (Part 2)

This is Part 2 of the Tunnels tutorial, Part 1 can be found here: Beautiful Algorithms 2: Tunnels.

Note: The code examples in this article might not appear in your feed reader.

Lookup Tables

Lookup tables are basically arrays of values.  Referring to elements in an array is faster than calculating them.  Doing this in Ruby is almost as simple as:

100.times.collect { |i| Math.sin i * (Math::PI / 180) }

The tunnels code calculates sin and cos for values that would evenly plot a circle for a given table size.  The table length is calculated based on precision:

@precision = 0.2
@inverse = 1.0 / @precision
@table_length = (360.0 * @inverse).to_i

I’ve also used the lookup class to store the current X and Y direction of the tunnels.  I’m using the lookup class a little bit like a global variable so other classes can coordinate with commonly referenced values.

Movement

Recall that rings are deleted when they get too large.  At this point the global direction is changed.  There’s a method called Lookup.change_direction which is used to do this.  Each time a ring is initialized the current direction in Lookup is referenced.

Change direction is random, but constrained.  This causes the tunnel to gently move around the screen as new rings are added.

Palette

A palette is created just like in the Fire algorithm, except this time it’s shades of blue rather than red to yellow.  As the rings get larger they get brighter too.

Putting it Together

The final example can be downloaded here: tunnel-p5r.  For instructions on how to run it, see the Fire tutorial.

Beautiful Algorithms 2: Tunnels

I spent weeks trying to reproduce dot tunnel effects on my Amiga back in the 90s.  Demo groups used to get thousands of points animated as complex 3D shapes and tunnels, but their techniques were way beyond me.  This tutorial introduces one such effect, and a few common techniques programmers use to improve performance.

For a video of the effect, check out my tunnel screencast.

This tutorial uses Ruby Processing.  See Fire Part 1 on how to get started.

Note: The code examples in this article might not appear in your feed reader.

Algorithm

The illusion of a 3D tunnel is creating by plotting rings.  For each frame of animation, each ring is scaled up.  The scaling rate of change increases as the rings get larger, giving the illusion of movement in 3D.

1. Create a small ring
2. Plot dots to display the ring
3. Make it slightly larger
4. If it’s large enough, add another ring
5. If it’s too large, delete it

Modern Interpretation

Back in the 90s most people would have implemented this as a set of loops, iterating through preset positions for the dots.  Since these tutorials use Ruby, we can represent a ring using a class.

Of course, this isn’t terribly efficient, but it makes the algorithm much easier to follow.

The class will look something like this:

Then the main loop will look like this:

As you can see, this algorithm is essentially very simple.

Lookup Tables

Lookup tables are a major technique for performance improvements.  Even modern videogames use them in some form.  Before drawing is performed, common calculations can be stored and referred to later.

The tunnel algorithm relies on sin and cos for plotting a circle: this is pretty basic trigonometry.  Even though these operations are incredibly fast on a modern computer, calculating thousands of them per frame of animation is not trivial.  Looking up values in an array is much faster.

Part 2

In part 2 I’ll show you how to fill a lookup table with values and plot the tunnel.  If you want to ignore all that and run the example now, get it off my GitHub account: tunnel-p5r.

Quite Useful Weekly Roundup

I started the Beautiful Algorithms tutorial series this week.  The first algorithm is fire, a cool graphical effect that’s actually easy to understand and create: Part 1, Part 2.  I also wrote about Git GUIs because I’ll be referring to Git more often in my programming tutorials.  Ric contributed a post about knowledge management and Swirrl.

Twitter Stuff

Avoiding iPhone App Rejection is quite an eye-opener for me.  It’s interesting that he notes compliance with Apple’s UI guidelines, when so many apps have hackish or terrible UIs.

The Hidden Costs of Apple’s Push Notification Service was another good iPhone developer article I’ll probably keep coming back to.

More developer articles of note: GitHub Issue Tracker, GitHub API, GitHub Pages.

I enjoyed these productivity related links Simon found: How We Work and Daily Routines.

Next Week

Beautiful Algorithms 2: Tunnels.

Git GUIs

In my Let’s Make a Game tutorial, I mentioned that my code could be downloaded with Git from GitHub.  I’m going to use Git for all of my tutorials on Quite Useful, so it’s worth getting familiar with it.

This post briefly reviews a few GUIs for Git, for those of you who don’t like the command line.

GitX

GitX is for Mac OS and is both free and open source.  It’s a native Mac client, so it has a clean interface.  The window defaults to History View; and the main panel shows the commit log, and the bottom panel shows the diff.  The bottom panel can be changed to show a file tree so you can view your entire repository.  The history shows branch merges with graphical visualisation.

There’s a button at the top-left of the window for switching between commit and history views.  Changing the view to Commit View shows lets you stage, commit and push changes.

Switching branches is fast, naturally, and the menu (at the top of the window) shows all branches including remote ones.

GitX is simple but it supports almost everything you should need for day-to-day git usage.  I think it would be a great tool to get people in your team started with git who aren’t comfortable with the command line.

Tortoise-Git

Tortoise-Git is available for Windows, and is both free and open source.  It can use Plink from Putty for ssh connections (most people who use git use SSH rather than the git:// protocol).

It lets you checkout repositories, view commit logs, branch, stash, rebase; pretty much everything!  It integrates with Explorer too, so it’s pretty easy to learn.

Gitk

Gitk actually runs in Windows, Linux and Mac OS.  It’s open source and free.  It’s a little bit more technical than the other clients here, but if you’ve installed git you should have it.  It’s primarily a commit browser, and has some good methods of displaying the graphs for branching.

If you’re using Linux another one to try is git-cola.

Swirrl: Quite Useful Knowledge Management

This post is by Ric Roberts, a developer at Swirrl who also contributes to Quite Useful.

Knowledge Management for Productivity

If a question about general knowledge comes up in conversation, it’s easy to immediately look it up on the web on your laptop or iPhone.  If you’re watching a film and you can’t place where else you’ve seen one of the actors, you can instantly look it up on IMDB.  You can even use services like Shazam to identify songs.  Finding stuff at work should also be this easy, but it normally isn’t. Although the information you want probably exists somewhere in your organization, it’s often scattered across multiple systems or you might not have access to the specific shared drive where it lives.

Being able to easily access the current knowledge in your workplace helps you do your job better.  It allows you to spend less time searching for information or tackling issues that others have already solved.

An Online Workspace for Sharing Knowledge

Swirrl is a web-based knowledge base application for helping your organization to capture, share and exploit its knowledge. Swirrl is based on the same priciples as wiki software.  i.e. it’s an online workspace for sharing knowledge, holding discussions, and storing information - giving people quick and easy access to the information they need.  Instead of communicating inefficiently by email, information can be stored in one easily accessible central location.  Work can be stressful enough without having to worry about whether you’re looking at the latest version of something.

Web’s Simplest Online Database

Ward Cunningham, the grandfather of wikis, described the wiki as: The simplest online database that could possibly work.  With Swirrl, we’ve taken this wiki database idea to the next level.  Inspired by Wikipedia’s tables of information (like the one in the screenshot below about the skateboarder, Tony Hawk), Swirrl lets you assign attributes to the items you’re describing in your knowledge base.

However, unlike the tables in Wikipedia, you can search, browse and explore attributes of Swirrl-Items.  In the future, more advanced search facilities and an API will allow users to harness the full power of this approach.  Swirrl helps you to understand your data and do more with it.

A Web-Native Approach

One thing you might want to do is combine data held in Swirrl with data held in other systems.  Behind the scenes Swirrl stores data as RDF, which gives users a flexible way to create simple data models, allowing data to be combined together in interesting ways.  Swirrl implements the Linked Data approach, which is all about making data linkable and browseable in a web environment.

Using simplicity to our advantage

Swirrl doesn’t enforce a rigid structure or process for dealing with your information.  Your knowledge base can grow organically as the experts on your data (i.e. the people in your organization who deal with it every day) use the application.  The knowledge held within Swirrl is structured by categorising, tagging and linking items together.

The principles in Swirrl should be familiar to anyone who uses the web: i.e. comments, tags, links and simple web forms. We’ve avoided the need to learn a wiki markup language by using a WYSYIWYG approach to editing. (Techies can still have access to the raw html if they want more control).  And by going down the hosted web application route, there is nothing to install or maintain, so you don’t need to waste your time fiddling about with configuring servers or software and there’s no need to get the IT department involved.

At Swirrl, we’ve tried to avoid the temptation to add complicated bells and whistles just because we can: we’ve concentrated on the features which we think are the most useful, and worked on making them easy to use.  For technology to be useful, it shouldn’t get in the way of doing your job.