i was just confused as to why you walk out of a car wreck and your biggest concern is missing my fake birthday

Last Monday the top item on my to-do list was to give my friend Rob a call for his fake birthday. Then I got distracted.

I’d borrowed a car for a weekend trip to Madison and was returning on Monday, March 19. I was in the right lane of I-90 when a pickup in the left tried to lane-change into me in his haste to cut around the guy ahead of him. When I braked to avoid a collision, I spun out on the wet pavement and ground backwards to a halt along the crash barrier in the median. The back bumper disintegrated, the side of the car was scraped deeply enough to tear off a door handle, the front bumper was hanging half off.

With luck, and many thanks to automotive and highway engineers, I was uninjured. (The pickup drove off, of course.) The rest of my day was taken up with a police report, insurance report, damage estimates, and an early bedtime. All the usual fallout of a car crash.

The next morning I was trading email with Rob and I told him the whole story of the crash, ending with:

Oh, which is all a long, elaborate excuse for saying I’m sorry I missed your birthday yesterday, Rob. Happy belated!

… thank you?

Wasn’t it March 19 what you moved it to like 20 years ago because you were sick of having a birthday up against Christmas? I thought it was 3/19 and I’m sure it was some lead singer’s birthday…

guitar player. it was Pete Townshend from The Who

you got the date right. i was just confused as to why you walk out of a car wreck and your biggest concern is missing my fake birthday

I’ve been chewing on this question, but the answer is easy: I’m really happy with where I am and what I’m doing with my life. The crash hasn’t made me think “Oh no, I’m wasting my life! I need to quit my job and work on NearbyGamers full-time! Or quit NearbyGamers and work 90-hour weeks! Or join a nunnery! Or win a triathlon!”

I wanted to get right back to what I was doing. I’ve thought deliberately about what kind of life I want, and I’m living it. And I can’t think of a better way to celebrate being alive than to enjoy a fond old joke with a friend.

Speaking of hours, I missed responding to something in his previous update:

Eventually, I’m going to create web interfaces for a lot of this stuff, but for now I’ll have to do any settings and etc. by hand in the database. By the way, the interface work isn’t strictly game-related and can be handled outside of So Play We All hours.

After the first week we said hours had to be budgeted towards code, but not marketing and blogging. It’s vague here, Jim, what are you referring to working on? If “interface” means HTML frontend, that’s code that’s gotta get counted, Luke and I both did a bunch of template work on budget.

Anyways, this week Jim’s got some nice top-to-bottom functionality done in his rendering engine. It felt a bit like my update about finishing off code from last week. He’s rendering a basic page:

We do not have DisplayRegions yet, so I am just some simple text. However, this page is now valid XHTML and not simple plain-text!

Congrats on the milestone, Jim.

Luke had writer’s block, so there’s not a lot to say there. I’m a bit puzzled that he doesn’t say “coder’s blocK” because the hours are budgeted towards that, but I can see how it’d be easy to open a code editor and then stare at it.

I’ve chatted with Luke a bit about his game design and thought it was pretty solid, similar to stuff I’d seen on Three Hundred Mechanics . This really sounds like he’s trying to see the entire design up-front and getting overwhelmed by it. His big questions are all certainly important ones, but maybe it’s worth figuring out if there’s a way to take smaller bites.

Jim’s got his first progress that doesn’t sound to me like he’s reinventing a wheel. The template for a page is broken down into DisplayRegions, each of which has a Controller (“Component”) responsible for loading the right data.

It’s an interesting PHP-styled take on MVC. The top-level code that handles each request isn’t a controller action, it’s basically a template split into code/settings (“DisplayEngine”) and markup (“PageTemplate”). The template then lists what controllers and actions should be invoked to handle the request, which is a not how I’ve ever seen any web MVC work before. It feels pretty stereotypical of PHP to have a template running the show, and I wonder how much logic is going to leak into them as a result. A common pattern is that a section of a page with links to register and sign in — or, if there’s a user logged-in, to edit account settings and log out. Jim, in your system, where does that if (logged_in()) { [settings/logout template] } else { [register/login template] } live?

This week, Jim had a brief but significant update, writing:

Well, after so many weeks of being seriously far behind, I’ll finally be making the progress towards being able to render a complete HTML page.

He’s written his Page, Session, and Form classes to the point that he’s only held back by not being able to template pages from displaying real pages. I’m a little surprised he got votes in this week’s poll without anything to demo, but it’s nice to hear things are coming together for him.

Actually, maybe I should be worried that he’s going to start displaying a game sometime soon. So let me mention a great Rails feature you should spend time reimplementing, Jim. The pending release of Rails 3.1 includes HTTP streaming, basically the ability to send parts of the page while still working on generating the page.

This is how PHP’s page-as-script model works out-of-the-box, but it often leads to bugs when state changes during the page rendering. I’ve seen a lot of browser based games with a bug where a page says you have 100 minerals in the header and then, lower in the page, say that you only have 50 because loading this page performed an action that spent 50 minerals. Having an explicit stage that builds and renders a page usually prevents these bugs at the cost of being able to send enough information for the client to get working at downloading page assets while the server is still performing work. Continuing to support that may cost Jim enough time in gold-plating to keep me comfortably ahead.

(But just in case it doesn’t the 3.1 announcement also mentions an asset pipeline that compiles and compresses CSS and JS for faster pageloads. Have fun, Jim.)

Luke laid down code for cards. I know I’m helping the enemy, but I’ve got to tweak it. His code is:

 
class CardController < ApplicationController
  def play
    play_sym = "play_#{@card}".intern # PH: this should be .to_sym
    self.send(play_sym)
    render :action => play_sym and return
  end
 
  def pocket
    pocket_sym = "pocket_#{@card}".intern
    self.send(pocket_sym)
  end # PH: no explicit render here? Feels like a paste error
 
  protected
 
  # plays
  def play_roland
    # Play the game to see what happens when you play the Roland card!
  end
 
  def play_water
    # Play the game to see what happens when you play the Water card!
  end
 
  # pockets
  def pocket_roland
    # Play the game to see what happens when you pocket the Roland card!
  end
 
  def pocket_water
    # Play the game to see what happens when you pocket the Water card!
  end
 
end

 
class CardController < ApplicationController
  # I'm guessing from usage above @card is just the name for a card as a string
  # and that it's loaded from the url by a filter, note that I use it differently.
  before_filter :load_card
  after_filter :default_render_card
  
  def play
    @card.play
  end
 
  def pocket
    @card.pocket
  end
 
  protected
 
  def load_card
    @name = params[:card]
    @card = "card/#{@name}".camelize.constantize
  end
 
  def default_render_card
    render :template => "cards/#{request.action}/#{@name}" unless performed?
  end
end
 
# add in config/application.rb:
module Oaqn
  class Application < Rails::Application
    config.autoload_paths += %W(#{config.root}/app/cards)
  end
end
 
# and then create app/cards/roland.rb:
module Card
  module Roland
    def pocket
      # code for pocketing
    end
 
    def play
      # code for playing
    end
  end
end

So now the cards each get a source file to themselves, templates have their own per-action dirs (better swapped to per-card dirs, if there are more actions), there’s less duplicated code, and it’s far easier to test these smaller pieces. The only thing missing from this example is the fact that Luke may have to pass some game state into the methods. As long as there’s not too much it’s probably worth being explicit about.

2011-07-09: Luke actually used this code and found it didn’t work as written. I found an explanation; either add ‘app’ to autoload_paths instead of ‘app/cards’, or drop the Card wrapper.

Meanwhile, in the past, Jim wrote some PHP, and I’m not touching that language.

No, in seriousness, Jim talked about why he has some identifiers surrounded by __ (which I’d called python poisoning). I haven’t dug into his code (again, PHP), but it looks like it might be an InBandSignal to reuse Events as framework steps.

And then he talks about session fixation attacks, which are have been protected against out-of-the-box on PHP with the session.use_only_cookies setting for a while. I was a bit confused, I’m pretty sure he’s actually describing session capture attacks. Oh, and there was some other stuff about writing code to store sessions in the database. If you’re curious, Jim, here’s the code for a Rails app to do that, which appears commented-out in the stock config file for your editing convenience:

 
  Oaqn::Application.config.session_store :active_record_store

It includes support out of the box for keeping sessions in cookies (encrypted, of course), your SQL database via ActiveRecord, or Memcached. I’m curious, how much of your budget did you spend storing sessions?

And, you know, I’m a huge fan of card games, so it’s nice to see another one in development.

As great as that is, Jim got my vote in this week’s poll.

In a post titled Deity Development he responds to some criticism and then links to the documentation for the abstract work I was hassling him about doing the last few weeks. I’m glad to tangibly see his progress, and it looks like he’s got a solid core built now.

As a web developer, I have a half-dozen for testing reasons, but one that I use for all of my personal browsing and most of my work. Very infrequently, I’ve noticed that it sometimes would have errors on web pages that other Firefox profiles didn’t. After some thinking, I realized that I’ve been copying the same Firefox profile nearly ten years, copying it between computers as I upgrade. And all the while I’ve been tinkering with it, poking around in its config files, testing extensions, changing options in about:config.

I wanted a fairly mindless activity today, so I recreated my profile from scratch, re-installing all my extensions and configuring everything just the way I like it. It took a few hours, and my notes ended up surprisingly long.

The few times I’ve thought about switching to Chrome I’ve looked for one or two of these add-ons and seen that there’s no equivalent. Now that I have these notes I can check comprehensively the next time I get the urge.

The notes will mostly be of interest to web developers. My browser is pretty heavily customized with tools, privacy protections, and productivity tweaks (mostly to make it feel like vim and allow me to pull things offline easily). It’s an intimidating list to look at, but it’s ten years of small changes every few weeks all at once.

Add-Ons

• AdBlock Plus http://adblockplus.org/en/
  • add EasyList (button in tab on startup)
  • ‘Options’ menu, uncheck ‘Show tabs on Flash and Java’
• Better Privacy
  • select any LSOs you want to keep
• Cookie Monster
  • uncheck “Automatically Reload…”
• Download Statusbar
  • General
    • check ‘Download speed’
    • uncheck ‘Keep a download history
    • check ‘Clear finished downloads when the browser closes’
    • ‘Automatically clear these filetypes’: *
    • after 90 seconds
  • Appearance – choose ‘Custom Style’
    • File Name Size: 9
    • Height: 13
    • check ‘Main Downloads Button’
    • check ‘Clear Finished Button’
    • check ‘Enable Speed Colors’
• FacebookBlocker
• Flashblock
  • check ‘Block Silverlight as well’
  • add any whitelist sites
• Greasemonkey
• LeechBlock
  • block tvtropes.com
  • General – check all
• Pentadactyl

  ~/.pentadactylrc

  "1.0b4.3 (created: 2011/01/05 17:55:12)
  
  loadplugins '\.(js|penta)$'
  set guioptions=BrsC
  set runtimepath=/home/harkins/.pentadactyl
  set urlseparator=,,s
  
  " vim: set ft=pentadactyl:
  

• NoSquint
  • Zooming tab, uncheck ‘Show current zoom levels’
  • Set ‘Default full page zoom level’ to 100%
  • Exceptions tab, add .github.com, .tumblr.com, .blogspot.com, .posterous.com
• Pixlr Grabber
  • uncheck ‘To edit images’ and ‘To edit backgrounds’
  • select ‘Always save to desktop’
• Readability https://www.readability.com/addons
• RefControl
  • click ‘Edit’ button, choose ‘Block’ and check ’3rd Party requests only’
  • outside of settings, right click button at bottom of window, remove icon
• Sauce Launcher https://addons.mozilla.org/en-us/firefox/addon/sauce-launcher/
• ScrapBook
  • Show up to: 10
• SQLite Manager
  • select ‘in a new tab’
  • uncheck ‘Always confirm’
  • uncheck everything in Prompts tab
• Tamper Data
• Tree Style Tab
  • Appearance
    • Skin ‘Sidebar’
    • Tree Twisties: choose ‘None’
  • Menu
    • uncheck all but ‘Reload this Tree’ and ‘Close this Tree’
  • New Tabs
    • uncheck ‘Always ask’
    • select ‘Open in new tabs’
  • Tree
    • uncheck ‘When a tab gets focus’
    • check ‘Double-click on a tab’
  • Advanced
    • uncheck ‘Enable Animation Effects’
    • uncheck ‘Show tree contents’
• UnPlug
  • Integration – uncheck all but tools menu
  • Downloads – ‘Preferred download method’: Save as
• User Agent Switcher
• Web Developer
  • General
    • Check to hide the context menu, confirmation, and informational
  • Validation
    • select CSS 3

Incompatible

These aren’t yet compatible with Firefox 5, so they didn’t get into my notes.

• Page Speed
• Resurrect Pages
• YSlow

GreaseMonkey Scripts

Sorry for the lack of titles, but this was annoying enough to compile already.

51281 62706 7705 23555 53547 60314 38516 31804 56690 100746 104489 38985 45032 75263 77801 94112 30646 23175 28374 29279 29682 29681 29829 29828 95298 29666 49366 74340 76300 45032

Toolbars

• right click on the toolbar, uncheck Web Development toolbar
• right click again, choose ‘Customize’, choose ‘Use Small Icons’ and remove:
  • read it later
  • search box
  • zoom buttons
  • home button
  • bookmarks button
  • FireBug button
  • drag GreaseMonkey button to status bar

Cookies

click on CookieMonster at bottom of window, click View Cookies, show exceptions.
‘Allow’ sites you regularly visit
‘Block’ google properties

Bookmarks menu -> Show all Bookmarks

‘Import and Backup’ -> Back up to json in old profile, Import ‘Choose File’ in new
Same with ScrapBook – open sidebar, Tools, Import / Export, select all…

Edit -> Preferences

• General
  • ‘When Firefox starts’: Show my windows and tabs
  • ‘Home Page’: about:blank
• Tabs
  • check everything but ‘When I open a link in a new tab’
• Applications
  • search for VLC, Windows, and QuickTime, change items to ‘Always Ask’
• Privacy
  • check ‘Tell web sites I do not want to be tracked’
  • select ‘Firefox will’: Use custom settings for history
  • select ‘Keep until’: I close Firefox
  • select ‘When using the location bar, suggest’: History
• Security
  • uncheck ‘Remember passwords for sites’
• Advanced -> Update
  • uncheck ‘Search Engines’

about:config

• browser.autofocus false
• browser.dom.window.dom.enabled true (new)
• browser.history_expire_days 30
• browser.tabs.animate false
• browser.tabs.closeButtons 2
• browser.tabs.loadBookmarksInBackground true
• browser.tabs.loadDivertedInBackground true
• browser.tabs.selectOwnerOnClose false
• browser.zoom.full false
• browser.jsannoyances.disabled true (new)
• downbar.display.clearButton false
• downbar.display.mainButton false
• downbar.display.percent true
• downbar.function.useAnimation false
• network.http.pipelining true
• network.http.pipelining.maxrequests 8
• network.prefetch-next false

~/.mozilla/firefox/[profile]/chrome

userChrome.css

 
    @namespace url("http://www.mozilla.org/keymaster/gatekeeper/there.is.only.xul");
 
    /* don't bold active tab title */
    /* no longer works, argh */
    tab[selected="true"] { font-weight: normal !important; }
 
    /* stop TreeStyleTab's Sidebar theme from changing its color when in/active */
    .tabbrowser-strip[treestyletab-style="sidebar"][treestyletab-mode="vertical"] {
      background-color: #ccc !important;
    }

userContent.css

 
    /* indicate nofollow links with a dotted blue underline */
    a[rel~=nofollow] { border-bottom: 1px dotted blue !important; }

Got any neat suggestions I’ve missed?

Meanwhile, Jim is apparently suffering from Python poisoning, because he’s naming events __LIKE_THIS__. He’s swirling into madness:

Once Version 1 is stable, I’ll compile a list of “official” Events that developers can utilize in their own projects.

No, I didn’t make that up. Not only is he thinking about a framework for multiple games, he’s thinking about a published framework for multiple games. Not, you know, his game. I see why Luke earlier used the phrase architecture astronauts. Jim, you are a great many abstractions away from writing a game, and I think the air is getting thin.

More encouragingly, Jim’s been writing about some of the deities in his game world: Dani, Rhegar, Nuri, Shisane, and Kesok. I understand the setting is largely based on long-gone-by D&D campaigns. It’s great to see some player-facing information.

Derek’s got a great career arc. He climbed up the ranks of journalism, covered Congress, and got involved in data-heavy projects. “Computer assisted reporting” is one of those terms that nobody quite loves but nobody’s successfully replaced (though it seems “database journalism” is gaining ground) and refers to collecting and analyzing data in databases. Derek got as interested in the “computers” as the “reporting” and has deliberately pushed his skills and career into software development. (*cough* sounds like a good topic for a quiet blog, eh, Derek? *cough). I look at his GitHub profile today and he’s been busily merging in contributions to his open source projects like his USA Today Census gem.

We started out the day looking around the FEC scraping code. In the States, the Federal Election Commission gives out lots of data from candidates filing required disclosure statements. We tidied up the database a little and then turned to the project for the day, which has just been publicly announced:

Today we’re announcing the addition of paper campaign filings from Senate candidates and two party committees to our Campaign Finance API, which previously had only provided details of electronically filed reports. Now users can request and view the filings of any committee registered with the Federal Election Commission. Unlike House and presidential candidates, current and would-be senators file their campaign reports first with the Secretary of the Senate, who then forwards them to the F.E.C. That agency then scans in the images from the paper filings and makes them available for viewing (an example). While an effort to require electronic filing for Senate candidates hasn’t gotten much traction this year, we have at least made the API’s set of filings more complete. New in the Campaign Finance API: Paper Filings

The scraper was previously ignoring the paper-only reports, but we updated it to recognize and categorize them. The categorization was a huge bit of nostalgia for me: take the noisy and sometimes inconsistent provided categories and map them onto a standard set of database categories (form_type, in the screenshot in the announcement).

When we ran the scraper, it would complain and halt each time it reached an unknown category. We’d add that to a mapping table and restart from that point, but it was frustrating to have to keep an eye on it. So we set the scraper to ignore records that it didn’t have a mapping for and warn about the problem. We set the scraper to run (and hit the amazing Shake Shack for burgers) and came back to find a list of missing mappings. After adding that, we ran the scraper again to fill in the missing entries.

This worked because the scraper only added entries it didn’t already have recorded. The term for this is idempotency, and it’s useful from the level of individual functions up to large, fairly complex programs like web scrapers. Every program fails, having an idempotent approach to the problem means you don’t have to keep careful track of many types of failure because you can fix things and re-run your program without worrying about duplicate records or updating things twice.

Derek had to run off to catch a train, so I dropped in on Dan Berko. He was on one of the Post’s several other “web innovation” teams while I was there, so we helped each other with code occasionally but didn’t spend a lot of time coding together.

The New York Times has large and well-maintained internal tools for reporters and editors. The reporters have a CMS for writing stories and the editors have a budgeting system for planning what goes where in the paper. We improved communcation between these two a bit, so the budgeting tool could refer to a story in the CMS and pull metadata from there instead of requiring an editor to re-input it.

The UI was simple: if the editor links a story, several fields should be grayed out and a checkbox should indicate the link. If the editor unchecks the box, the link is broken and the fields become editable again. This started out with two code paths – one for linking a story, one for unlinking – and making sure on pageload that the UI was in the proper state. We’d barely started writing that when we saw it could be implemented even simpler:

 
disable_if_linked_to_cms: function() {
  var checked = $('asset_cms_id').checked;
  ['asset_home_status_id', 'headline', etc.].each(function(id) {
      $(id).disabled = checked;
  });
},
document.observe('dom:loaded', function(){
  Event.observe('asset_cms_id', 'click', Budget.disable_if_linked_to_cms);
  Budget.disable_if_linked_to_cms();
});

When the checkbox is checked, all the form fields are disabled. When it’s unchecked, they’re not. The code runs on pageload and anytime the checkbox is toggled. I really liked this bit of code: we started out writing the simplest thing that came to mind, but soon we realized it could be reduced. The resulting code probably elicits a “So what, it’s not doing much?” reaction, which is far better than the previous “Now, let’s see, what’s this doing?” we would’ve had at first. The sign of the best code is that you immediately understand it, not that you have to stretch yourself to follow its solution.

Luke did well this week as he started to build out his combat system, including party members who (unless he’s hacked it in, but it doesn’t look that way) respond to locations and enemies. It’s a start at gameplay, though your choices are pretty limited so far. I like the idea in the blog post about having party members you can configure but not directly control, it reminds me of Ogre Battle.

Also, he’s started the storyline, including “the fact that the bear can’t seem to find you is important”. When you play, the bear enemy appears to be completely incapable of attacking you. Just for wild-ass guessing’s sake, I’m going to guess the player starts as some kind of ghost. We’ll see how I did when the storyline takes shape.

Jim… continued to work on the controllers for his web framework, as he did last week. I felt like this:

> Application creates CommandRouter and TemplateDisplay instances

I’m very happy for it.

> Application retrieves Events from the CommandRouter for the current Post data (usually none)

So, it’s like how PHP populates $_GET and $_POST for you before invoking a script, but redundant.

> Application retrieves Events from the CommandRouter for the current URI

Events are sounding awfully general purpose. Wasn’t this a game? I feel faint.

> Application loops through the current events (events can be added while processing other events) and calls the CommandRouter->ProcessEvent() method for each one

It’s a generic message queueing system. The world is going dim…

> CommandRouter creates any necessary controller and sub-display instance for the event and passes all data to any module event handlers registered for the current event

It is pitch black. You are likely to be eaten by a grue.

> Created controllers determine models to use which add their data to the relevant Display objects (which are further applied to the TemplateDisplay instance)

No, really, a grue. It eats developers who don’t finish games.

> Application renders the TemplateDisplay

The grue dies of boredom.

Jim mentioned he liked the Mortal Kombat drawing last week. I guess he didn’t click on it. It’s a link to a great article, which includes:

3. DON’T ROLL YOUR OWN TECH IF YOU DON’T HAVE TO

There are pros and cons to writing your own engine. But ask yourself, do you really have to? Is what you want to do impossible to do with what’s already out there or would you be reinventing the wheel? Of course, if you write your own engine you can make it just perfect the way you like it. But be honest, how often do you ever get past the engine to the game itself? Do you find yourself making game engines more often than you do games?

Bring the thunder, Jim.

Meanwhile, Jim’s done great, getting code live for the first time. I took a screenshot:

The first page has a simple login form. There’s no way to register an account, and any login/password you enter gives you the above message. In his blog post, Jim wrote about the code

At that point, it was a fairly easy task to take the user object and add its data to the display for rendering. I chose to go with something like:

Hello %user%! Your account was created at %time% on %date% and you last logged in at %time% on %date%. Enjoy your stay!

STOP IT. You are writing a template language in a template language! Templates are the one thing PHP actually does pretty decently (well, it’s not Haml, but it’s way better than TAL)! Wrap PHP’s output buffering around include() and get on with your life before you find yourself implementing conditionals and loops.

This is part of a larger topic I have to respond to:

This is mostly because I had to rush myself just to even get this far and put in lots of sloppy code. So, I’ve decided that I don’t care how far ahead the others get, I am not going to worry about matching their pace.

Really, it was an unrealistic goal that I’m glad to be letting go of. They’re using a pre-built framework which means they have options to solve a lot of their issues right out of the box. I, on the other hand, have to implement even my low-level functionality. This means that I’m going to be slower to execute no matter what happens. That’s the price that I pay for wanting to use my own implementation. The positive upside is that once I manage to solve these issues, they’ll be solved for me in all of my future games and I’ll be able to skip this tedium the next time around. …

Sure, it slows me down in terms of this competition, however, I will have 100% control over every aspect of the process which is not something that I would have if I were to leverage Drupal to build the game.

I know you write good code, Jim, but satisfice, man. You’ve got the worst time demands of all of us. Luke and I aren’t barfing into our editors and making sure it passes a syntax check, we’re taking acceptable components from other people so we spend our time on the important bits.

Last week I bought and added a theme to Oaqn. I was hugely tempted to tear it apart and make sure everything was perfect, with semantic class names and no unused code and efficient selectors and and and… Instead I added achievements, a feature that will help inspire and retain players for the lifetime of my game. That code’s not perfect, either, I already know I’ll want to tweak it to add some kind of bronze/silver/gold upgrading medals — but now I’ve got something decent in place and I can get closer to a running game.

Finish a game. So Play We All.

Allabrilyn

Jim wrote about a lot of technical progress, but unfortunately it all falls into the category of invisible infrastructure, there’s nothing for a player to see. It really reminded me what a huge boost Heroku is for hosting: not only is initial deployment about 5 minutes, it prevents you from spending time tinkering with your server setup for only minimal gains. (I don’t know how he got more votes than me, I suspect sympathy from similarly frustrated PHP coders.)

In all, it’s been a difficult 4 hours… but well worth the effort, in my opinion. I believe the extra headaches I’m taking now will allow me better flexibility in the long-term.

The bulk of his post seems to be about improving his own ORM and site infrastructure. Ouch. It sounds like he’s written some nice code, but this contest is about building one game, not building the next ten games.

Maybe the Real Ultimate Power of Drupal will make it a breeze to drop in community features like a forum and a chat, but right now he has nothing to see and he’s falling behind.

Fantasy Adventure

I’m glad to hear Luke’s stepping up his game after his brief blog posts for week 0. Not that I don’t mind easy competition, but I don’t want people to think I rigged the contest by setting myself up against a sucker. :)

In seriousness, Luke did great this week, he got my vote in the poll. We both used Devise for registration, but he got his basic install much faster and then streamlined it to make it easier for people to get into his game.

Yes, into his game! I’m not sure if it’s just static text or he created a basic player object with a few attributes, but he threw together a decent template and you could click around to move between different locations. Currently there’s just a bit of cute story to read, but that’s enough for the player’s imagination to start filling in gaps and imaging a world. (Also, bonus points for using delightful PlaceKittens, I’ve bookmarked that as a resource.)

That ability to fire the imagination is a great sign for Luke’s prospects. Time for me to go step up my game in response.

Showing off his superior time management skills, Jim quickly posted about Allabrilyn. It sounds like a collectible card game (or maybe LCG). That the collectible elements are units for a tactical game is… awfully familiar.

I dropped Athenge as a project because I realized I love the genre, but it’s actually really uncommon. Tactical wargames have a hardcore fanbase (a blessing and a curse), but it’s certainly not a big one. And building a game around PVP that’s mostly based on the player’s skill progression means there’s going to be a lot of dissatisfied bad players who don’t want to participate. So I think it’s great that Jim is building my kind of game, but I worry about his market. (And Jim – don’t just sell random packs, add a premium currency that players can use to auction/sell cards between themselves with so that you don’t create a secondary market that gives you support hassles but not income.)

Next up, Luke explained Fantasy Adventure Game. I loved this post (though of course, not so much that I voted for it over myself). He’s immediately willing to be imperfect in public by beginning with a terrible working title. It’s a great sign for getting over embarrassment to develop something great. I’m terribly jealous that he included financial info from the start; I’d wanted to but it slipped my mind. More guts!

As for the game itself, it leaves me a little flat. I’ve seen too many games default to fantasy; I hope he finds ways to turn his ignorance into interesting genre redefinition rather than middle-of-the-road generictown. It really sounds like it’s a single-player RPG (having not played KOL), so I think he’s going to have problems with producing content (items, quests, skills, etc.). Multiplayer interaction, competitive or cooperative, is wonderful content because you can set up systems that players fill up with content. It takes a fraction of the time to code a PVP game like chess than it does to write a text adventure like Adventure, and chess is probably fun for far longer because it becomes about other people, and people are interested in people.

I also have one criticism to level at both games: there’s nothing for the player to identify with. In Oaqn, the player controls a single caravan, that’s them in the world. (And I very likely will add some kind of human player avatar to play dress-up with eventually, because that’s even better.) In Allabrilyn and FA, the player controls a collection of characters, so there’s nothing for them to feel represented by or invest in the well-being of. This is why RPGs (and many other games) have a heroic mime character leading the party, so the player has an empty template to fill up with their personality. It’s much harder to do that with a deck of cards or a small troupe, and it’s a powerful motivator for casual online games.

My lengthy braindump rocked this week’s poll, with 6 votes for me, 1 for FA, and 0 for Jim (who I guess is not even active enough on the forums anymore to even vote for himself). I’m happy for that, but I think I’m going to face stiff competition that’s constantly thinking of things I’ve missed. So all I can do is plan to steal those things like revenue details for next week, muahaha! (Speaking of which, I’d better go put in my hours before I wind up owing these guys money.)

2011-06-13: We’ve built a website with the current rules and progress updates at So Play We All.

Our Rules

1. “Fuck it, we’ll do it live.” Games are live as currently developed, even if they suck, starting from “but it’s just a login screen”. Develop on master, develop on prod box if you have to, but don’t hold any code back.
2. Each week we’ll collectively choose how many hours to spend on our games and a non-mandatory topic. Anyone who doesn’t spend the time (or cheats and spends more) funds the other games by giving a $20 gift card to each other player for game-related expenses (eg. ThemeForest, Linode, AdWords). If you finish early, you rock. Boast a little bit and make the others bow to your awesomeness. (Exception for suiting up: if you have to wear a suit to a funeral, a close family wedding, or a court date, you are allowed to miss that week. No other exceptions, not even dismemberment.)
3. Deadline is Wednesday at noon GMT to deploy code and publish a blog post, schedule it to make it happen.
4. A BBGameZone forum poll judges who won that week, 24h window.
5. By Saturday noon GMT, write a blog post to respond to others’ updates, talk smack, enjoy victory, critique game design, suggest improvements, etc.
6. Not just OK but encourage to find or buy assets: art, themes, libraries, modules. You can reuse your own pet library as long as it has been released publicly before that week, but outsourcing code is forbidden.
7. Whoever reaches $10k in profit first wins the contest. But whoever turns their game into a full-time job wins all the bragging rights.
8. Rules can change by unanimous acclaim.

So say we all. So play we all.

Week 0

We’ve already gotten under way, the goal for our first week was to pick a domain name, set up a blog, and write a blog post describing out game. Here’s my blog post about Oaqn, a game about trading. Please vote for it on bbgz if you’re on the forums.

And here’s Luke’s post and Jim’s post about their games.

Aidan and I hacked away at adding a feature to a Web App That Shall Not Be Named. User authentication was handled by Facebook or Twitter, so the feature was to fetch and list their friendships from their social network. The code in app/models/user.rb was straightforward, taking an object from authentication:

 
# Update the database with the user's current list of friends.
# Compares a fresh list to the existing list to minimize database writes.
def update_friends(auth)
  # fetch current list of friendships as hashes
  provider_friendships = auth.retrieve_friendships
  # load already-stored friendships to hashes
  stored_friendships = friendships.send("on_#{auth.provider}").map { |friend| {:id => friend.friend_id, :name => friend.friend_name} }
 
  # compare the two lists of hashes
 
  # add any new friends to the database
  (provider_friendships - stored_friendships).each do |friend|
    friendships.create!({
      :friend_id => friend[:id],
      :friend_name => friend[:name],
      :provider => auth.provider,
    })
  end
 
  # delete any removed friends from the database
  (stored_friendships - provider_friendships).each do |friend|
    friendships.destroy_all(:conditions => { :friend_id => = friend[:id], :friend_name => friend[:name] })
  end
end

That code isn’t very complicated, but it’s worth noting before you read the next snipped that we were both new to the Facebook/Twitter APIs and spiking functionality rather than trying to write production quality code.

Keep that in mind as you read the code we added to the authentication object. It works, but it could definitely be better written (left as an exercise to the reader, because, well, we only spiked, so I haven’t actually written a better version to present).

 
def retrieve_friendships
  if provider == "facebook"
    # made the Facebook API call
    user = FbGraph::User.me(self.data['credentials']['token'])
    # map it to an array of hashes
    return user.friends.map do |friend|
      # check against the db to load their id
      existing = Authentication.where(:uid => friend.identifier, =
:provider => 'facebook').first
      { :friend => existing ? existing.user : nil,
        :provider_id => existing ? nil : friend.identifier,
        :provider => 'facebook' }
    end
  elsif provider == "twitter"
    # Returns only 20 users at a time - is it important enough at this = point to add all the code for iterating? (aidan)
    # return Twitter.friends(nickname).users.map{ |friend| Hash[ :id => = friend.id, :name => friend.screen_name, :provider => 'twitter' ]}
    return {}
  else
    raise "Refactor me"
  end
end

Having the authentication object test what provider API it should be loading from is an obvious code smell, but it’s not the one I want to talk about.

There’s an implicit type in use. Aidan and I referred to it as a FriendHash, it’s a normalization for comparing friendship objects from the app’s database and from different API calls. FriendHash would be a data class with just a smidge of validation code to account for all three attributes.

I’ve noticed these sneaking around code in the interfaces between objects. I don’t quite have a name for them, but I realize it touches a bit on design by contract. The part that smells to me is that this code is spread amongst many places that need to be updated in sync with each other (not that this is terribly better if you have a class for it, but at least you can grep for references to it). I’m not a big fan of data classes, so I don’t love this solution.

What really frustrates me is that I’ve got enough experience to have a tingling intuition when I am attempting to re-solve some problem that surely someone else has analyzed and offered solutions to, but my resesarch hasn’t turned anything up.

So I’m posting to hear what folks think of this situation. Have you read anyone writing about these quiet but complex data types at interfaces, or do you have ideas for how to address them?

The Setup

You are a survivor of the zombie apocalypse in a town with up to 39 other players. It runs on a 24 hour cycle, and each day you get six Action Points (refillable 1-3 times per day, depending on what items are available) to scavenge for items and build up shared town defenses. If you die (which can happen individually or because your town is overrun in the nightly zombie attack), you can join right back into a new town tomorrow.

The core game mechanic is a sort of iterated prisoner’s dilemma, you have to choose to keep things back from the town or contribute to the town, and then socializing with other players to decide what defenses to spend your very limited resources on.

But the basic prisoner’s dilemma isn’t much of a choice, you learn after the first town or two that it is always much better to collaborate with your town, you cannot survive solo at all. But this does take you a town or two to learn.

The typical town is dominated largely by newbies who haven’t yet learned the necessity of collaboration. They don’t form a majority of members, but it only takes a handful of newbies to waste key early resources or disable town defenses shortly before the attack. The mechanisms required to police this are weak, the game simply doesn’t report who wasted the resources to start construction of the wrong building.

The Grind

This is where the grind comes into play. You can collect experience points that carry over between towns. There’s still no character improvement, the only benefit is unlocking the ability to play in towns that require 100xp. That is, in towns that have no newbies.

The typical newbie-ridden town fails in 1-3 days due to wasted resources and compromised defenses, so a good attempt will earn you 6xp, but 1-3 is typical. You’re staring at 20-40 towns, 2-3 real-life months, before you can start in a town without newbies.

Experience points really do track player experience in this scenario. The player will definitely be very well-experienced by the time they reach the milestone. But it’s incredibly frustrating because you’ll be playing the same game over and over: day 1 everyone yells to build a workshop but someone wastes the needed resources on a portal lock instead, day 2 a bunch of people get stranded outside of town and need rescue, day 3 the town fails. (Sometimes this all happens on day 1, or someone doesn’t give the needed click to turn on the defenses so there’s a total party kill of the town.)

I’m in a guild (“coalition”) with two friends so we’ll appear in the same town, but none of us has moved to get us into a new town in two weeks because the game is so boringly repetitive. We understand the basic mechanics, but we simply can’t play because there are too many newbies and idiots. I could see this being an awesome game to play with a dozen friends, but I don’t want to subject them to several months of grind to get to the “real game”.

A Solution

One thing the game does do right is that if you join a guild with 100xp-friends you can still be pulled along to their town. You probably won’t be a problem newbie because you’ll be relying on your friends in a town that’s already running smoothly.

Spitballing with Ammon (who I’m currently staying with in Austin, TX), I think one improvement would be to start sorting players by experience points immediately. In addition to the 100xp cutoff, put players into towns with similar amounts of XP every time they join a new town.

Each successive town the player joins they’ll see fewer newbies in a town that survives a little longer. Even if there’s a bit of a grind up to 100xp, it’ll be more fun because you’ll see new things each town.

Second, the game really needs to give complete disclosure of who spent resources so that experienced players can quickly and directly responds to newbie wastage. If a newbie already isn’t paying attention to the forums (where people always repost the now-standard Day 1 strategy), they’re not going to learn what not to do because no one knows who they are to reach out to (and perhaps smack) them.

I know a lot of my readers think about game design, what are your solutions? You have a game that’s built around collaboration with other players, but it’s frustrating because new players can’t effectively collaborate.

I’ve been increasingly dissatisfied with it since Rackspace bought the company. They added a monthly fee on top of storage costs for no reason, stopped issuing source code to a standalone program for retrieving data, performance hasn’t kept up with my growth in usage (open dialog to choose which files to back up, get coffee), it does an 80MB download on every startup, backups of even a few K finish with a tens-of-megs metadata upload, and now they plan to reduce client-side functionality.

2. New Web-based User Interface

In the spirit of flexibility and accessibility, the next release will have the configuration and setup totally managed via a web-based user interface vs. one that is incorporated into the computer’s operating system. In one simple interface, you will be able to manage every user and computer in a secure web experience that is familiar regardless if you are managing a Windows, Mac or Linux machine. This aspect of the update has been a huge undertaking for us because we want this to be a great user experience. Luckily, we have some pretty amazing talent that is helping us to build a truly awesome UI. The Road Ahead from the JungleDIsk blog

While JungleDisk used to sport "you don't have to trust us" encryption, this new UI means they'll need to keep a list of all of your files. And as much as I love the web, the desktop UI to JungleDisk is already painfully slow and clunky; the web adds network latency, browser overhead, and a much-reduced selection of widgets.

This is the last straw for me. After surveying the field I've settled on tarsnap. I'll write another post with more information on why I chose it and how I've set it up (it's a pretty low-level tool) when I've finished the big re-upload, cleaned up the remainders of JungleDisk, and settled into a regular rhythm.

That calls for a way to sync files, and Dropbox is by far the most convenient way to do so. Dropbox Just Works to copy files between computers, whether on Linux, OS, or Windows. Even an IT department that doesn’t want to install a development suite will probably be OK with it.

But software always calls for version control, it’s essential to keep track of changes. Git happens to be the right version control software for her project, so here’s the steps we worked through to set up her environment.

First, she created her repository inside her Dropbox folder. We’ll call this the dropbox repo.

 
desktop:~/Dropbox $ git init project
desktop:~/Dropbox $ cd project
desktop:~/Dropbox/project $ # create and commit first files

Now she has convenient access to her files across her computers, but there’s a pitfall: if she were to edit and commit to the dropbox repo on two machines that were offline, Dropbox would merge the git metadata in unpredictable ways. Each machine needs its own repository for work done in it, then changes can be deliberately pulled up to the authoritative Dropbox repository for integration. Edits done on a machine without git installed can be left in the Dropbox repo until they can be checked in, which works well enough for this scenario.

Creating a local repository is simple:

 
laptop:~/ $ git clone ~/Dropbox/project
laptop:~/ $ git remote -v
origin  /home/username/Dropbox/project/ (fetch)
origin  /home/username/Dropbox/project/ (push)
laptop:~/ $ cd project
laptop:~/project/ $ git pull # to get the latest changes

The laptop repo shows that it knows about the dropbox repo, and a git pull will bring in any changes. But git push will give a giant error:

 
laptop:~/project/ $ git push
Counting objects: 157, done.
Delta compression using up to 2 threads.
Compressing objects: 100% (152/152), done.
Writing objects: 100% (157/157), 982.50 KiB, done.
Total 157 (delta 44), reused 0 (delta 0)
remote: error: refusing to update checked out branch: refs/heads/master
remote: error: By default, updating the current branch in a non-bare repository
remote: error: is denied, because it will make the index and work tree inconsistent
remote: error: with what you pushed, and will require 'git reset --hard' to match
remote: error: the work tree to HEAD.
remote: error:
remote: error: You can set 'receive.denyCurrentBranch' configuration variable to
remote: error: 'ignore' or 'warn' in the remote repository to allow pushing into
remote: error: its current branch; however, this is not recommended unless you
remote: error: arranged to update its work tree to match what you pushed in some
remote: error: other way.
remote: error:
remote: error: To squelch this message and still keep the default behaviour, set
remote: error: 'receive.denyCurrentBranch' configuration variable to 'refuse'.
To /home/username/Dropbox/project/
 ! [remote rejected] master -> master (branch is currently checked out)
error: failed to push some refs to '/home/username/Dropbox/project/'

This is one of git’s more unix-like error messages, in that it makes sense once you already understand it and happens because git is an incredibly powerful, flexible tool that assumes you know what you’re doing. Let’s walk through the error.

Everything down to the “Total” line is git giving you information about how it’s packaging the data to send between repositories and is normal.

The first paragraph is warning that you’re pushing code to what’s currently being worked on in the other repository (the “checked out branch”). Git can’t know that the other one is just files sitting around – what if it’s some other user’s, and he’s in the middle of editing things? Well, if someone else might be using it, we can’t update the files in the working copy, because it would trash his work. But if git doesn’t do that, the remote repo knows that it’s not at HEAD – meaning the next commit will confusingly create a branch.

The second paragraph is saying “If you’re sure you know what you’re doing, you can configure the remote repository to let you do this.”

The third is saying “Or you can just tell me to shut up.”

Finally, the last few lines are git attempting finish the push. It says “OK, with everything ready, I’m going to push” and then “Wait, I couldn’t push from my master to the remote master” and “you told me to push at least one branch and at least one failed” (in this case, excatly 1 and 1). In short, git is refusing to take the risk of maybe screwing up work.

There are two responses.

The first is to make the Dropbox repository a “bare repository”. That means it will have all the history of the project, but no checked-out, editable copies of the project. That would stop you from conveniently reading the files wherever you happened to be, though. When you have a repository on GitHub, that copy on their servers is a bare repo – GitHub doesn’t have any interest in editing the files and doesn’t want you to have this problem.

The second is simpler, and what you want to do for this situation. Pulling changes is always OK, because git knows you know what you’re doing with the current repo. So, from the dropbox repo:

 
laptop:~/Dropbox/project $ git remote add laptop ~/project
laptop:~/Dropbox/project $ git pull laptop master # note that you have to name what branch to pull from
From /home/username/project
 * branch           master -> FETCH_HEAD

Git reports the path to the repo it’s pulling from and which branches it was able to update, in this case master from what it found on the remote HEAD. Success!

All that’s needed to add more machines is to run the git clone on them and then, from the dropbox repo, add them as remotes for pulling changes.

Dropbox and git play nicely when you need their different strengths.

We worked on FindAPair, a small web app he’s developing with Jeff Powell. Developers can list their city and link to their Twitter and GitHub profiles to find other devs to pair with. (Yeah, this basic idea felt pretty familiar.)

First, Jim and I added some acceptance tests using Steak to test profile editing. Steak is a DSL for acceptance in BDD, but closer to Ruby code than the popular Cucumber. Jim explained he chose Steak because this project does not have a non-technical customer who’d read, verify, and help write specs. Cucumber’s translation between text files and method calls would be unnecessary complexity.

FindAPair uses the wonderful Devise library, so we followed the steps on the wiki to allow people to log in by username as well as email address. It went pretty well, but we needed to do a little tweaking for Rails 3. Of course, we contributed back to the docs. One of the nice things about GitHub is how frictionless it is to share these small improvements.

Another interesting bit of coding was planning the URL structure of the site. The two major resources are users and the cities they live in. Jim wanted to have really simple URLs like findapair.me/jimiray or findapair.me/denver. He didn’t want to overlap the namespaces, but he couldn’t decide between them. As he was explaining the problem I thought back to the early days of the web and suggested putting cities at the root and users at findapair.me/~jimiray. Jim laughed, decided the audience was nerdy enough to remember it, so we committed it.

I’m not going to recount all the little things we did, but it was a fun afternoon building what could be a great resource.

While I was programming with Jim, I was reminded of the importance of studying. I knew a lot more vim commands than Jim, but it’s not because I’m any smarter. When I started learning vim I quickly realized it was a far bigger topic than I could absorb at once, so I only learned enough to take care of my daily routine. After I was comfortable with that, I started reading the vim manual, but I read at most one chapter a week. Read a little, experiment, give it time to settle, refresh my reading in a few days, and then move on to something else. In the decade since then, I still watch for new information about vim, reading the vim subreddit and Twitter accounts like learnvim and dotvimrc. It’s easy to skip over the stuff I already know. It’s easier to earn in small amounts over years than read one book and hope to retain everything.

One result? If there’d been a hundred people I’d have been done right there, but if there’s exactly one person, well, why not say hi? So I sent an email that I think sounded like this:

I realize I’m a complete stranger and the idea of wandering into people’s offices to work with them for a day sounds perfectly ridiculous, but would you like to grab coffee, talk code, do some pair programming?

Perhaps I didn’t come off quite so badly because David said “what the hell” and invited me to meet him for his workday at Traders Coffee.

A side story: I happened to arrive before him and was looking around for him, and couldn’t see him. But I saw a woman surfing Stack Overflow! I thought maybe this was someone David knew and invited along, so I had an awkward conversation where it quickly became clear she had no idea who I was or why I was introducing myself. If I’d been thinking quicker I’d have invited her to join us or at least given a business card, but my generic nerdly social phobia overwhelmed me and I excused myself. If you’re reading this and someone interrupted your Stack Overflow session to ask if you knew a guy you’d never heard of, sorry for the confusion, but if you’d like to grab coffee, talk code, maybe do some pair programming, I’m in town until Friday afternoon.

As David and I sipped delicious lattes, I learned that he’s a mechanical engineer who got into software development around ten years ago as his job changed. He’s self-taught, he cracked the books and started experimenting. Along the way he attended some Construx Seminars. Construx is the software firm started by Steve McConnell, the giant who strides above programmers bestowing books of wisdom and lore, so that gave David a good grounding.

A lot of our conversation was about how David has found it hard to improve his craft without other, ideally better, programmers around to work with. It’s referenced by the community aspect of the Software Craftsmanship Manifesto. Programmers improve their craft by improving each other’s craft.

As an example, David told me about his startup project veloGraf. He and another developer are using graph algorithms to analyze social networks and I soon realized I only know enough graph theory to hang onto the ankles of the conversation. I hadn’t thought about it before, but David pointed out that game tags on NearbyGamers form a highly cyclical graph. Gamers add edges to the graph by listing what games they’re interested in playing and tags self-referentially describe themselves (eg. Dungeons and Dragons is tagged as a an RPG).

I demoed the site’s most computationally-expensive page, which shows gamers who share tags, sorted by distance. This page required some hacking to avoid a gigantic couple of joins that would’ve dragged in most of the rows in the RDBMS, but David chuckled because it’s the sort of problem a proper graph database doesn’t even notice. He’s tracking millions of nodes with many times more edges in order to extract interesting connections. The simple analyses he pointed out flaws in common algorithms that were obvious to him but surprising to me. I managed to give him some fodder for experiments to improve his algorithms, which says more about the value of a little collaboration than it does my graph chops.

David told me a tale of (mild) woe from a previous job. An experienced cowbody coder was developing the core of a product while supposedly mentoring interns. In reality, they were restricted to working on small, ancillary tasks so as not to destabilize the core or distract the cowboy. How do you fix this?

My best guess (share yours in the comments, please – it’s not an uncommon scenario) was to task the interns with adding automated testing. The cowboy will think of it as menial work, but the interns will be exposed to the whole system and have reasons to have conversations with him. And probably better to start with acceptance testing than unit testing to preempt the cowboy from whining that using unit tests to verify that his code works (as opposed to hack and hope and oh yeah, I forgot those two things were related) slows down his brilliance.

There’s a complacency I’ve seen that’s sort of related to the Blub Paradox. When a programmer succeeds at building their first product or two, they often get an panglossian sense of competence. They may think, “I’m good at my job, there’s people telling me I should learn these things, but I’m good at my job without them, ipso facto I don’t need to learn more.” Unless they’re around a noticeably better programmer or especially introspective, they may never realize how much more there is to learn and the possibility of much greater skill.

I think this is where net negative producing programmers come from. I joined a project with an NNPP once. I watched all commits to the repository (everybody does this, right?) and I realized nearly his every commit added a bug or the strong potential for future problems. There was feedback available in the rising bug count and frustration of trying to improve the codebase, but he didn’t have the experience to know that this experience was abnormal. (Or at least improvable.) As I and other developers started cleaning up the code, he recognized what had been happening and decided to reinvest in his career by attending training.

I think this is why the nascent software craftsmanship movement has such potential. Programmers need to make steady improvement, however small, a core value of the profession. Currently there’s a “well, it works” when practice and mindful improvement could be a precept. The likeliest way I see that happening is masters of the craft mentoring apprentices. Every craft has its share of “just get it done”, but it doesn’t have to be the dominant culture.

Update: David has blogged his thoughts on our wide-ranging conversation.