class Post
    include DataMapper::Resource
    property :id,       Serial
    property :title,    String
    property :body,     Text
    property :created,  DateTime
    property :author,   String
 
    validates_present :body, :title
 
    has n, :categories, :through => Resource
 
    def self.latest_by_author(name)
      all(:author => name, :order => [:created.desc])
    end
 
    def self.count_by_author(name)
      count(:author => name)
    end
 
    def categories_as_comma_list
      categories.map { |x| x.name }.join ', '
    end
 
    def categories_as_linked_comma_list
      categories.map { |x| "<a href='/archive/#{x.name}'>#{x.name}</a>"}.join ', '
    end
 
  end
 
  class Category
    include DataMapper::Resource
    property :id,       Serial
    property :name,     String
    validates_present :name
 
    has n, :posts, :through => Resource
  end

My new Sequel classes:

  class Post < Sequel::Model
    many_to_many :categories
 
    def self.latest_by_author(name)
      all(:author => name, :order => [:created.desc])
    end
 
    def self.count_by_author(name)
      filter(:author => name).count
    end
 
    def categories_as_comma_list
      categories.map { |x| x.name }.join ', '
    end
 
    def categories_as_linked_comma_list
      categories.map { |x| "<a href='/archive/#{x.name}'>#{x.name}</a>"}.join ', '
    end
 
  end
 
  class Category < Sequel::Model
    many_to_many :posts
  end

Ignoring the migrations and validations, next to nothing has changed. All of my queries work as expected. They’re inefficient because I’m not giving Sequel any hints on how to handle them, but that will hopefully change soon as I migrate to using Sequel’s DSL to specify queries, and stop using models altogether. I’ve been mucking around in the ORM debate and the more I think about it, the more I’d like to use a lightweight language to describe my SQL, rather than hand it all off to a more complex ORM, which is exactly what Sequel provides me.

Well, not just any old Gantt charts. Specifically, Gantt charts created with GanttProject, a multi-platform, open source Project Management application. Charts saved in this format are easily parsed into nice neat lil Ruby objects.

You’ll need GitHub as a gem source if you don’t already have it (gem sources -a http://gems.github.com):

$ sudo gem install ardekantur-gantty

And get ready! It’s like this:

  @gantt = Gantty::Open '~/CorporateProject.gan'
 
  @gantt.tasks.first.name         # => "Research and Development"
  @gantt.tasks.first.start.to_s   # => "2008-01-01"
  @gantt.tasks.first.end.to_s     # => "2008-01-15"
  @gantt.tasks.first.duration     # => 15

You can see what tasks are active for a certain day — the entire reason I wrote this:

  @gantt.tasks.size                               # => 30
 
  # See tasks that are active today
  @gantt.current_tasks.size                       # => 5
 
  # Specify which date to see tasks from
  @gantt.current_tasks(Date.new(2008,1,6)).size   # => 8

Finally, mix it up for some intense data aggregation!

  @gantt.current_tasks.select { |t| t.coordinators.size > 0 }.collect \
    { |task| task.coordinators.collect \
    { |dude| "- #{dude.name} should be working on #{task.name}." }}.flatten.sort
 
  # => [
  #      "- Adam Alpha should be working on Requirements Document.", 
  #      "- Bob Beta should be working on Requirements Document.",
  #      "- Bob Beta should be working on Website.",
  #      "- Ed Epsilon should be working on Website."
  #    ]

Hideous and beautiful, all at once.

Fork it at its GitHub repository! I hope to add some more features over the weekend, like seeing task dependencies, percentage of completion, and resource focus percent on tasks.

I’d like to put together the ideas that allowed me to clear up this issue, as well as solve another problem I was struggling with. This is my way of giving back to the community. As fun as I’m sure it would be to ensconce myself in the cultures, practices, procedures, languages, politics, and other detritus of several large, entrenched open source projects just to solve a single problem… oh wait.

My problem surrounded three central elements. The website in question is a website for my undergraduate design seminar in Computer Science. As the designated administrative lead, my job is to keep everybody connected, organized, and on top of things. To this end, our group agreed on the use of Subversion, Trac, and a central website for any blog posts we feel would contribute to the discussion of our problem domain.

How each person approaches a problem is nuanced, and — if it can be explained and backed up with evidence — does not have to rigidly adhere to one scheme or another. Whereas in the creation of my blog I was satisfied with subdomains, I wanted this project to use subdirectories off of a root domain: less typing to get to the beginning of a URL than the end, less futzing around with Apache, and so on.

Thus:

• http://example.com/ would be the blog,
• http://example.com/trac would be the Trac landing page, and
• http://example.com/svn would be the Subversion repository end-point.

Already, the amount of code involved has exploded (Apache, mod_wsgi, mod_rewrite, and mod_dav_svn, Subversion, Trac, Sinatra, Rack, Phusion Passenger) and no matter how I looked at it, the answer was going to be ugly. When everything was finally set up, the three applications were fighting for breathing room. I could run Trac and SVN together, and my application worked perfectly through Sinatra itself and on my dev machine, but putting them all up on the same site caused the Sinatra app to slow to a crawl on requests. It was when I finally disabled everything else but Passenger did I see the same problem occurring.

Some people call it the ‘Slow First Request’ problem, and recommend several pooling and request options in Passenger’s configuration to mitigate the problem. I didn’t see that as being the same problem, really: There’s no reason why this application couldn’t feel “always on”, ready for team members and potential meetings and presentations.

I began disassembling my solution to narrow down the problem, and in doing so, considered replacements. I initially considered Apache my staple, and therefore beyond reproach, so I began at Passenger. I replaced it with Thin, and attached its instances to Apache with mod_proxy and ilk. Now it ran like a dream! Then I re-enabled all the other sites in Apache.

Now, I’ll admit. I’m not an HTTP guru. I may not fully understand mod_rewrite, I might not completely grasp Apache configuration directives. You may not either. Or maybe you do, and you just can’t fucking wrap your mind around why Apache refuses to redirect everything in its proper place even though everything makes sense to you, at 6:30 in the morning while you nurse a hangover. In this case, the shit I was shoveling finally convinced me to rip out Apache, and it was the best thing I could have done.

I installed lighttpd and immediately fell in love with it. First I configured Trac with it, before stepping back, aghast in horror in the amount of site-specific code filling the lighttpd.conf file, and replaced it with a proxy to Trac’s stand-alone server. Next, I wrote a proxy for Apache to deal with SVN — out of the way, on another port number, since its mod_dav_svn was more adept at handling the htpasswd-specific authentication I required.

And finally, I attached the Thin instances I was running to the configuration file. Now all Lighty did was exactly what it was supposed to: guide traffic to and fro.

### Various Connections
$HTTP["host"] == "example.com" {
proxy.server = (
        "/trac" => (
                ( "host" => "127.0.0.1", "port" => 9090 )
        ),
        "/svn" => (
                ( "host" => "127.0.0.1", "port" => 8080 )
        ),
        "/" => (
                ( "host" => "127.0.0.1", "port" => 3000 ),
                ( "host" => "127.0.0.1", "port" => 3001 ),
                ( "host" => "127.0.0.1", "port" => 3002 )
        )
    )
}

Beautiful. And not an iota more information than is necessary to do its job.

I’m running the Trac daemon with the following options:

/usr/bin/python /usr/bin/tracd -s -p 9090 -b 127.0.0.1 /var/trac/project/ --base-path=/trac -d

The --base-path option ensures tracd doesn’t get confused and try to redirect traffic to http://example.com, instead of http://example.com/trac.

So thanks Hongli, for an actually constructive suggestion. I did consider REE, before I took a step back and walked through everything. Phusion Passenger is a great product and I don’t mean to knock on it, but I do worry that it’s a sort of behemoth when compared to smaller Rack-lite applications that it can run. However, when it comes to understanding exactly why, I’m way out of my league. I’ll let the experts decide how to factor this in, or if my complaint has any merit at all.

Believe it or not, Linus’ Law is not the universal solution to everybody’s problem, nor is one an idiot (around here it’s okay to use bad words) if they don’t immediately succeed in everything they do, the first time through. In my case, the solution was letting every piece of the puzzle fend for themselves, doing what they did best. And I didn’t have to join a single mailing list, or ask for a single commit bit, or write a single specification. On top of that, I’ve still helped the programming community, because now we all know a little bit more about how to handle this scenario.

I’d also like to take the opportunity to laugh at the idea that it was my Ruby application itself that was the bottleneck in this situation. While I admire the kind of omniscience that doesn’t even have to look at code to consider it FAIL, that’s not actually a diagnosis. That’s zealotry disguised as nonchalance.

# passenger-memory-stats 
-------------- Apache processes --------------
PID    PPID  Threads  VMSize    Private  Name
----------------------------------------------
2654   1     1        242.0 MB  0.0 MB   /usr/sbin/apache2 -k start
2102   2654  1        363.0 MB  4.3 MB   /usr/sbin/apache2 -k start
2135   2654  1        372.0 MB  5.0 MB   /usr/sbin/apache2 -k start
9454   2654  1        367.1 MB  4.9 MB   /usr/sbin/apache2 -k start
10339  2654  1        364.0 MB  3.8 MB   /usr/sbin/apache2 -k start
10396  2654  1        363.7 MB  15.7 MB  /usr/sbin/apache2 -k start
12279  2654  1        378.5 MB  6.5 MB   /usr/sbin/apache2 -k start
12280  2654  1        362.4 MB  6.3 MB   /usr/sbin/apache2 -k start
13714  2654  1        359.3 MB  5.4 MB   /usr/sbin/apache2 -k start
16431  2654  1        242.0 MB  0.2 MB   /usr/sbin/apache2 -k start
16433  2654  1        242.0 MB  0.4 MB   /usr/sbin/apache2 -k start
### Processes: 11
### Total private dirty RSS: 52.48 MB

--------- Passenger processes ----------
PID    Threads  VMSize    Private  Name
----------------------------------------
2097   13       143.7 MB  0.2 MB   /usr/lib/ruby/gems/1.8/gems/passenger-2.0.2/ext/apache2/ApplicationPoolServerExecutable 0 /usr/lib/ruby/gems/1.8/gems/passenger-2.0.2/bin/passenger-spawn-server  /usr/bin/ruby1.8  /tmp/passenger_status.2654.fifo
2098   2        51.1 MB   1.5 MB   Passenger spawn server
16438  1        120.3 MB  20.5 MB  Rack: /webapps/AppOne
16440  1        120.3 MB  40.2 MB  Rack: /webapps/AppOne

What a fucking joke.

Ta-da:

#!/bin/sh
sed -e '/\<NAME/d' -i '' "$1"
sed -e 's/\<MEMO/\<NAME/' -i '' "$1"

Save it as quickenImportManip.sh, and run it:

$ chmod +x quickenImportManip.sh
$ ./quickenImportManip.sh YourQuickenFile.qfx

Then import away!

	- (void) testSettingPositionString
	{
		NSString * pos = [NSString stringWithString:@"rnbqkbnr/pppppppp/8/8/8/8/PPPPPPPP/RNBQKBNR w KQkq - 0 1"];
		[conv setPositionString: pos];
		STAssertTrue([conv positionString] == pos, @"Position string not set");
	}

:-)

Rancher’s Delight, if you don’t know, is a game engine I’m making based on the SNES classic Harvest Moon. Its primary goal is to faithfully recreate the underlying engine for the original game. Once that is done, I will extend it to allow for a programmable system that will enable anybody to create any kind of Harvest Moon-like game they wish.

What I accomplished this weekend:

• removed the old code that dealt with resizing the viewed area to make sprites and locations larger. If I need this again it can easily be rewritten, but it has to fit into the new underlying framework.
• wrote different functions to take into account the character moving versus the world scrolling under him. The former is used when there’s no more location to scroll in that direction, and coming away from the edge of a map where he’s not in the center yet. The latter is used for everything else.
• added in-game objects, and ensured that they are stationary with the background when the character moves.
• added a prototype of the messaging system, using font rendering for the messages and a surface with the original dialogue box on it. It can fit a bit more content than the old fixed-length one, but the content needs to be hand-checked to ensure it doesn’t spill over the edge of the box. It may be worth it to enforce a cut-off just in case.
• started enforcing cardinality in a character’s facing direction, along with slowly putting together sprite sheets.
• started playing around with, then polished off, cycling sprites for movement.
• completely refactored everything up to this point, making everything a lot cleaner. There’s now a sort of God object, the Camera, which takes care of all kinds of relationships between things. Already a lot more relationships can be refactored out, but I can’t see the most effective ways to do so until the whole thing gets a lot more complicated. Primarily I’m starting to see the difference between an object doing something, and the user seeing what it does.
• introduced a frame length to cycled sprites, which I’ll need to tweak along with the movement speed to get the best recreation of how Jack moves in Harvest Moon. This is really important to get right, as a the timing of the game and how people play it rely on the movement of the main character for precise schedules.
• stitched together the exterior of the farm, where all the magic happens.
• created a tool to replace the soon-to-be game objects in a location (such as the stumps and weeds in the exterior farm) with random ground tiles. Fairly simple and effective.

So, yeah. A decent amount of work. You can keep track of the progress on the GitHub feed of commits for the project, as well as test and try it out yourself by cloning my repository:

git clone git://github.com/ardekantur/ranchers_delight.git

In the meantime, here’s a pre-release screenshot :-) It’s Jack spending some alone time on the church roof.

• my fork of rest-client
• bulletin
• wondercroc
• uproar
• clementine
• flint
• quandry
• ioaxiom
• taskforce

If you had any interest in any of these projects, let me know and I could provide you the source, or any guidance for what I had planned for them. As it stands, this leaves me with Taskomaly, which I’m slowly waning interest in since my move to Things, and Rancher’s Delight, which, as a game and a very large undertaking, probably won’t see a lot of progress. This leaves me with a virtually clean slate with which to start thinking about problems I’m interested in solving.

GUIDs are good but I wanted to do one better. So I created SUUIDs. Super Universally Unique IDs. The format of the current version, v2.0, is thus:

2/xxxxxxxx-xxxxxxxx-xxxxxxxx-xxxxxxxx-xxxx

Where x is a case-sensitive alphanumeric character. This gives us somewhere in the area of 3.35×10^64 possible combinations, and a lot of interesting characteristics.

• For example, if the address space of a given ID is all hexadecimal, and the last four characters are IPv6, this functions just as well as an IPv6 address format. Thus, The IPv6 address 2001:0db8:0000:0000:0000:0000:1428:57ab is notated as 2/20010db8-00000000-00000000-142857ab-IPv6. If a field contains all the same character, you can replace the ending hyphen with a comma and the field with a single instance of that character, so that IP address could also be 2/20010db8-0,0,142857ab-IPv6.
• In the same token, the same rules apply to a message that ends in 0MD5 — that’s an MD5 checksum as well as a unique address.

An implementation in Ruby:

	module SUUID
	  def self.gen
	   chars = ("a".."z").to_a + ("1".."9").to_a + ("A".."Z").to_a
	   x = [8, 8, 8, 8, 4]
	   x.map! {|i| i = Array.new(i, '').collect{chars[rand(chars.size)]}.join }
	   return "2/" + x.join('-')
	  end
	end

It’s not pretty, but it gets the job done. You could always throw a more random source of entropy at it, use the system date, time, whatever. Don’t particularly care about the implementation.

Here’s what a couple look like — to get used to the idea :-)

2/f9nuBgzm-HGTE4bSK-ZEfkfsRp-T3SXgpXA-5LNC
2/hoyOCd7o-V48NQGvv-OS5RBDIl-CG1FRNqG-Xd3j
2/sUZd6aGa-1J55rs9C-lxH1mvPA-I9PAvkOh-ZLVj

Additionally, you can omit the version number, which so far still allows for distinction between version 1 and version 2 (version 1 didn’t have lowercase letters). This means you have a nice set of directory names at your disposal.

mkdir /DOMejDTy-APESCioG-yyXpXBNL-lYAuQogL-Uep9
mkdir `curl -X POST http://example.com/suuid/provider`

I have no idea how checksums, hashes, verified randomness all fit into something like this. Just something fun and stupid to keep me occupied today.