The problem is, about 1/3 to 1/2 of them [design patterns] were basically cover-ups for deficiencies in C++ that don’t exist in other languages. Although I’m not a huge Perl fan anymore, I have to admit the Perl community caught on to this first (or at least funniest). They pointed out that many of these so-called patterns were actually an implementation of Functional Programming in C++.

I’ve had the ranty discussions about how the singleton could be better known as globalton typical of any developer who’s heard that joke:

I’ve never understood why people bother with all that mucking around with instances. Just tag the object initialization on to the end some startup script like the database initialization and add ‘global $map;’ anytime you want to access it. It’s a global variable; most languages have very succinct idioms for managing those, unfortunately.

Singleton has a very small niche managing some hardware access and then is abused approximately all of the time as a noisy version of global variables. Seeing this over and over kept me thinking about whether design patterns are indeed mostly a standard set of tools for working around language deficiencies. (ObSlander: It’d certainly explain the Java community’s fixation on them.)

I’ve had an urge to reread Design Patterns and work through them in a high-level language like Ruby or, better, JavaScript.

But it turns out, as usual, that Peter Norvig is way ahead, with a 1998 presentation on design patterns in dynamic language noting that in some languages design patterns are simply invisible. Unfortunately he didn’t leave behind a detailed pronouncement of opinion as to the value remaining in design patterns when a language invisibly supports the most common patterns at the least, so I suppose I still have the exercise ahead of me.

Most of the questions are intended to start interesting conversations about the workplace, though a few (“Which source control do you use?”) do have wrong answers (“None.”) that end an interview as quickly as a candidate being unable to solve FizzBuzz.

Job

• What is your typical day like?
• What are the normal work hours?
• What is the office environment like? Can I see it?
• What is the job title?
• What is the employee review process?
• What benefits? (medical, dental, vision, 401k, transit, vacation, bonuses)
• How is the team at deadlines?
• Is there continuous learning?

Company

• Who are your clients?
• What makes the company special?
• How do you see the company growing?
• What are the NDA/NCAs?
• How long have employees been here?

Coding

• What is the codebase like? Can I see it?
• What tools do you use?
• Which source control do you use?
• Is your build and deployment process automated?
• How often do you build or deploy?
• What testing (automated + Q&A) do you have in place?
• What bug database do you use?
• Is your code great or good enough?
• Do you release open source code?

Manager

• What’s your personal management style?
• What books have influenced you the most?
• What technologies do you plan to use?
• Do you have any concerns about my application?
• Do you think I would be a good match for this position?

Do you have any questions you always ask?

The non-spam review sites might have more, but they also have professional photographers taking the pictures. (And if they’re not professional, someone who reviews dozens of cameras is going to take better pictures than you.) It doesn’t help answer the important question, “If I buy this camera, what will my pictures look like?”

The solution is the Flickr Camera Finder. When you take a picture, the camera embeds metadata that includes the brand and model. With tens of millions of photos, Flickr has samples from ordinary people using every kind of camera. (If you’re considering a camera that is not yet released, read the manufacturer’s and professional reviewer’s sites to find out about the sensor other internal technology; most new cameras are pretty close cousins to previous models.)

When you bring up Flickr’s page for the specific camera you’re interested in, search for the kinds of photos you’ll be taking. I knew I’d be taking lots of indoor shots of my friends and medium-range snaps of interesting things I see in daily city life, so I searched terms like “party”, “basement”, “couch”, “hanging out” for the former and “graffiti”, “bus”, “intersection”, “storefront” for the latter. I was able to avoid two cameras that I thought were great but turned out to be fairly poor for my needs.

The standard improvement is to use fixtures, a file with some example data, that your tests can load by giving the name of a fixture. Here’s one of the fixtures for a gamer:

alice: # alice is heavily involved
  id: 1
  mail: alice@example.com
  handle: alice
  password: red queen
  teaser: Follow the white rabbit.
  profile: Not so plain, after all.
  homepage: http://www.example.com
  jabber: alice@example.org
  location_id: 3
  last_login: 2006-10-30 11:56:08
  created_at: 2006-10-30 11:56:08
  location_at: 2006-10-30 11:56:08
  tag_text: dnd, wod
  mail_on_message: true
  mail_on_nearby_discussion: true

This is straightforward, but location_id is the id of another fixture in another file. As you can imagine it’s pretty easy to get them out-of-sync and break some tests. I end up leaving little comments in the YAML to remind myself of the cross-reference.

It’s awfully tempting to reuse fixtures from test to test. Maybe Alice was written to test logging in with a username and password and next I’m writing the test of logging in with an email address and a password. I could copy and paste Alice to another fixture to reuse in that test, but as a programmer I have a pathological aversion to copy and paste. Alice is going to get reused (most of those fields are optional and were used by very different tests), and after this happens a few times it’s hard to change a fixture without breaking an unrelated test.

I’ve gotten a lot of use out of fixtures as I’ve developed the habit of testing all my code, but reuse has made my tests somewhat brittle. After a bit of research, I’ve moved over to using factories.

Here’s the factory for a gamer:

 
Factory.sequence :handle { |n| "Gamer_#{n}" }
 
Factory.define :gamer do |g|
  g.handle { Factory.next :handle }
  g.mail { |m| "#{m.handle}@example.com" }
  g.password 'secret'
end

Only the essential, required fields are listed. Using this simple template, the tests themselves specify the values of the fields they’ll be testing.

 
def test_login_with_valid_username_and_password
  gamer = Gamer.create :handle => 'Alice', :password => 'red queen'
  ...
end
def test_login_with_valid_email_and_password
  gamer = Gamer.create :mail => 'alice@example.com', :password => 'red queen'
  ...
end

Ideally, changing a fixture wouldn’t break any tests at all. And factory_girl (what I’m using for factories in Rails) makes associations easy:

 
Factory.define :post do |p|
  p.association :discussion, :factory => :discussion
  p.association :poster, :factory => :gamer
  p.created_at Time.now.utc
  p.body "Post Body"
end

Now my tests include the specific data they care about, making them easier to understand and improve. And they don’t interrelate, so they’re much more reliable. I do still use fixtures, but now they’re exclusively for tests that need to deal with real-world examples.

1. Get a marker and an index card or piece of paper. Copy this and substitute your personal information:

2. Take a picture of it with your camera (or phone). Poke around in the camera’s menu, almost all have a way to mark photos as protected from accidental/mass deletion, so set that on this picture.

3. The last step is hard: don’t lose your camera. You might not succeed at this step, but if you’ve done the first two steps maybe you’ll get it back.

I’ve had this little collection at my bedside for a dozen years. Well, not this collection.

I go through the index cards pretty quick, so they need regular replenishment. And sometimes they’re a tear-off pad of paper. Or sticky notes.

And this pen is a pretty recent replacement of the one I emptied. The brand and model don’t matter one whit, don’t be a moleskine nerd.

There isn’t usually a little flashlight, that’s way optional. It’s nice, at night, when I’m adding to a note, but I can use the backside or another card if I don’t have a light.

And for a couple years the whole pile was actually a small digital voice recorder.

This is not a post about some clever tool for increasing productivity. That’s a picture of a sleep aid.

When I lay down to fall asleep I’m still sorting through the jumble of the day and I think of things I left undone, or I plan tomorrow, or I have little inspirations for projects, or I realize I forgot to do something, or I have an upsight about how to improve some code, or, or, or, or…

I can’t fall asleep when I’m juggling several thoughts, trying to keep them all in the air until I get up in the morning. I have to get rid of them, get them out, evaporate the fear that I’ve lost track of something. Keeping a pen and notecard, or any other way of recording thoughts, in easy reach is how I relax to fall asleep.

Some nights I don’t write down a single thing. Some nights I write down three dozen. Most nights I write down one or two things. Very infrequently, I jot down all the clutter and with it all cleared away I realize I have an idea so big and important I have to get up and get a full-sized piece of paper to sketch it out, to get it all down or to dive into it and start exploring the implications and producing the work and making things happen. But most nights I sleep very well.

That’s how the conversation started: no hello, no context, right to the heart of the matter. I love it when fellow geeks IM me.

My friend has a lot of experience in software and tabletop games, but has stayed away from the Privacy Destroyer. From the outside, online games didn’t seem to make any sort of sense – if it’s one free click to add a game to a social profile, how do you sell your game? How do you make any money at all?

The answer is that there’s a bit of advertising and merchandising, but by far the bulk of the profit is in virtual currencies. Pay $10, get 75 gold coins you can spend in-game on items, upgrades, downtime removal, etc.

It’s successful because it allows for perfect market segmentation. Some of your customers are willing to pay much more for your product than others, whether you price low or high you’ll lose some potential profit. Losing potential profit is deeply painful to entrepreneurs, so you sell a copy of the product at the low price and another at the high — and to keep it from looking silly, you differentiate them by calling one “premium”, or limiting quantities of one, or selling it in a bargain bin after six weeks, or selling in different venues (soda machine vs. grocery store); anything that lets you charge multiple prices with a straight face.

If you do this wrong, people will mock you mercilessly and the nerds will point out you’re really selling only one product. (But you won’t notice because you’ll be busy trucking your wheelbarrows of cash down to the bank.)

This is so powerful that Facebook games (and a growing number of other games with low distribution costs) are “free to play” (f2p) or “freemium”. You can play as long as you like for free and buy virtual currency if and when you see something interesting.

Virtual currencies allow for perfect segmentation. If Alice thinks your game is worth $5, that’s what you’ll get from her. If Bob thinks it’s worth $5,000, you’ll get it from him for the exact same game. I’m not exaggerating; last week a payment processor shared data on their top five spenders:

From a traditional gaming perspective, Facebook games look like the purest kind of bubble, a lunatic asylum dosed with crystal meth. Don’t charge for your game? Don’t sell expansions? Get everyone to bother their friends? Offer gold coins for taking surveys?

It’s not insane, low distribution costs and efficient capturing revenue so efficiently means a fundamentally different business model. And a great environment for making games.

Leland on GitHub

Features:

• Shapes: rectangule, hexagonal (‘circle’), freeform (‘free’)
• Variable hex sizes
• shape() to calculate distance in hexes
• highlight a hex
• set a border on a hex
• color a hex
• add text to a hex
• I swear it used to allow setting a background picture, but I don’t see that functionality so maybe I dreamed it or lost it when I misplaced this code for four years.

Known Issues

The code has ugly styling (tabs, odd spacing, no optional braces) – sorry, I was young(er) and stupid(er).

There’s a fair amount of temporal coupling in there – functions that you can’t call before other functions, etc. I hadn’t heard of the command pattern or closures yet.

There’s a bug in the ‘circle’ shape (that the following code exercises):

 
<?php
 
require 'class_hex_image.php';
 
$radius = 3;
$map = new Hex_image;
$map->set_color('bg', 255, 255, 255);
$map->set_l(20);
$map->set_shape('circle', $radius);
$map->start();
for($x = 1; $x <= $map->xsize; $x++) {
    for($y = 1; $y <= $map->ysize; $y++) {
        $map->text($x, $y, 'black', $map->steps($x, $y, $radius, $radius));
        // nice for getting a feel for coordinates
        //$map->text($x, $y, 'black', "$x,$y");
    }
}
 
header('Content-Type: image.png');
$map->finish();       // calls imagepng()
 
?>

Future

One of the guys in #bbg on irc,freenode.net is building a browser-based game with a hex map and I remembered this code was squirreled away somewhere on my hard drive. I have no plans to fix, improve, or in any way maintain this code. I figure I may as well release it so someone can do something with it.

License

I release this code to the public domain. You may use it for any purpose with or without attribution. It would be polite to mention my name and let me know you come up with, but it’s not at all required.

I don’t spend a lot of time thinking about my personal finances, mostly I adopt a policy of benign neglect and it’s allowed me to save up enough to work for myself exclusively. Instead of designing a precise system that accounts for every wayward penny (which is pretty much what my inner nerd cries out for) I’ve designed good habits and trained my intuition to create a low-key monitoring system that keeps expenses down.

The most important thing is that whenever I feel like I’m spending more money than I want or don’t have a good feel for where and how much I’m spending, I start a spreadsheet. Here’s an old example (with a few numbers fudged for privacy and example purposes):

Category

Category is whatever’s useful: when I worked in an office, I had a ‘Lunch’ category for when I bought lunch instead of bringing my own. Learned the expense of that fast. Sometimes I have a generic ‘spoiling myself’ or ‘entertaining in’ and ‘entertaining out’ categories. You have to invent your own.

Amount

Both positive (income) and negative (expenses), making it easy to select the column to see the sum at the bottom of the window. Usually I use the menu item Data -> Filter to create a filter on category to make it easy to add up these subtotals.

Essential

Similar to ‘Amount’, this is for the bare necessities: rent, groceries, medicine, schoolbooks. When I enter some groceries, that might be Amount -$72.18 but Essential -$51.52 because I bought some wine and candy. It’s a lot harder to reduce this category, but it helps for exposing optional purchases.

Notes

Reminders to myself about what this was or if I could’ve done it differently. The goal of the spreadsheet is to train my intuition into sync with reality, like remembering that movie tickets and popcorn for two cost $29.50 now, not $12 when I first started going on dates.

So when do I feel like making a spreadsheet?

Mostly by not using credit or debit cards; aside from the former’s fees and debt eating me alive, I use cash so I can see it go. If I’m at the cash machine more than once a month or wanting to withdraw more than usual, that’s my cue to stop and look at the spreadsheet a bit to figure out where I’m overspending. When I’m at the bookstore on the 8th with a stack of books under my arm and I look in my wallet to see that I’d have $20 left after buying them, I’ll tuck the cash back in my wallet and look at the library card that’s in there instead. It’s much easier to physically look at my budget in my pocket than to stop and try to recall the current numbers.

I don’t think I’ve ever run one of these spreadsheets for more than 10 weeks or so – I find out where I’m spending money, I make changes, and I track again when things feel off. I’ve done it I think four times in the last 8 years, mostly after I move. I put all my receipts in my wallet and trained myself to fill in the spreadsheet anytime I hit reload in my feed reader – which usually means once a day in the evenings, but of course you can tie to any daily event.

As I’m building a feel for my expenses, I’ll also try to lower them. The best thing is to look at monthly bills. For rent, search Craigslist for places your size and in your neighborhood with a max price of what you’re paying now (and min price of $5 to avoid the unethical marketers who enter $1 or $2), then subscribe to the RSS feed in the lower-right corner. After a few days or weeks you’ll have a feel for what your budget can get you and know if you should renew your lease or even think about breaking it.

All you can do for utility bills is reduce use, get better about turning off unused lights, turn the thermostat down and wear all those nice long-sleeved shirts. That’s the blessing and curse of regulation.

Reducing other bills, well, there’s a pain-in-the-ass way to lower them. Call every single one and say “I’m concerned about my bill. I think I’m overspending. I’m considering other companies. Can you do anything to reduce my bill?” It’s an awkward conversation, but a lot of times a loss prevention department will give you a big reduction in price to keep you on. Works especially well on phone and cable companies.

It’s really easy to procrastinate on this one, no one likes to feel demanding or chintzy, but that attitude only helps them. I get over it by asking every time I’m annoyed at poor service, outages, or friends bragging about the deals they’ve gotten. Anytime my internet connection is being particularly Comcastic, I would say something like “How are you going to compensate me for this?” or “I just got a flyer from [the other guy] offering $x/month” (and not mention this is only the first Y months). In the last few years my internet connection has been on some kind of teaser or discount rate roughly half the time.

In short, I’ve avoided designing a complicated, explicit system in favor of an implicit system based on habit. I’m writing this out because a friend asked, but I think the worst thing he could do is adopt it. The particular habits don’t matter, design habits for your particulars. I share mine to explain the thought process and give some food for thought, anyone care to share their own?

Street Fighter taught me about yomi: knowing the mind of the opponent. You can’t just play the odds and do the textbook-correct responses, you have to adapt and anticipate your opponent’s moves. The game is merely a medium through which you play against the other player.

Games vary in how much they require skill at yomi, and it occurred to me that a game including yomi skill precludes a game having a Nash equilibrium.

a solution concept of a game involving two or more players, in which each player is assumed to know the equilibrium strategies of the other players, and no player has anything to gain by changing only his or her own strategy unilaterally. If each player has chosen a strategy and no player can benefit by changing his or her strategy while the other players keep theirs unchanged, then the current set of strategy choices and the corresponding payoffs constitute a Nash equilibrium.

Stated simply, Amy and Bill are in Nash equilibrium if Amy is making the best decision she can, taking into account Bill’s decision, and Bill is making the best decision he can, taking into account Amy’s decision. Likewise, a group of players is in Nash equilibrium if each one is making the best decision that he or she can, taking into account the decisions of the others.

Wikipedia

Games like Street Fighter, Kongai, coker, chess, are interesting because they don’t have evolutionarily stable strategies, every player is obliged to change their strategy in response to another player’s change. If a game (or one decision in a game) has a Nash equilibrium, there is no value to yomi, the player doesn’t need to know what the other player plans.

The blog was started by Peter Christensen and has one or two other contributors. With two Peters involved, here’s the handy guide to tell us apart: He’s the guy in Chicago named Peter who’s building a startup around an unconventional web-based game and I’m the guy in Chicago named Peter who’s building a startup around an unconventional web-based game.

Name didn’t warn any customers this was coming and didn’t email customers about it, which is funny because they’ll send a half-dozen warnings if a single domain name nears the end of its registration. They know very well the effectiveness of sending emails, so instead they made a brief blog post (who knew they even had a blog?) to announce the price hike as quietly as possible. The post doesn’t mention the new price is $8/year (laughably saying “While some registrars charge as much as eight or nine dollars per domain for this service”) and falsely claims pre-existing domains will continue to receive free privacy protection (the control panel shows that this will expire when the domain is up for reregistration). Unsurprisingly, the comments have filled up with comments from angry, shocked customers and Name is only responding to the few people who had billing problems with the related pricing promotions.

I’ve got around a hundred domains registered, mostly because I handle domain registrations whenever I give a friend hosting. It’s worth the $800 per year to take a few minutes this morning to survey competitors and maybe get better customer service (besides this unpleasant surprise, I’ve never seen Name respond to a support request in less than 36h).

In the table below, domain cost is the highest cost I could find on the site for a .com, I’m not interested in dancing around promotions and “restrictions may apply” loss leaders. The “upselling” column is whether I was disgusted or confused by the amount of upselling of related domains and products during the registration process. Survey was taken on 2010-05-03 and prices ending in .95 or .99 were rounded up.

I didn’t include Fabulous because it has great prices but is primarily (only?) for domain parking and requires customers to have >750 domains. I didn’t include GoDaddy because I don’t like their support of torture and their habit of deactivating/deleting/holding hostage domains in response to any outside complaints.

If you’re not familiar with domain names, they’re a perfect commodity. Except for customer support issues (easy bulk management, quick responses to questions, downtime), every .com domain is exactly the same and costs the company the same $6.86 to register with Verisign, the .com registry.

Anyone have a registrar I should add to the list? Any stories, good or bad, about managing a lot of domains at any of these?

I was reading through the blog of one of the GitHub cofounders and an article caught my eye because it described a process very similar to the one that I’ve heard from people who don’t use any version control:

You start your project in a directory named working. As you code, you try to write one feature at a time. When you complete a self-contained portion of a feature, you make sure that all your files are saved and then make a copy of the entire working directory, giving it the name snapshot-0. After you perform this copy operation, you make sure to never again change the code files in the new directory. After the next chunk of work, you perform another copy, only this time the new directory gets the name snapshot-1, and so on.

I like this because doesn’t insult anyone for using a process like this (as I’m occasionally tempted to do). Instead, he sees it as the first step toward the design of a distributed version control system (DVCS) to manage the process. He explains how a version control system encapsulates all the best practices people have learned from decades of coding and collaborating into a reliable software tool.

The following parable will take you on a journey through the creation of a Git-like system from the ground up. Understanding the concepts presented here will be the most valuable thing you can do to prepare yourself to harness the full power of Git. The concepts themselves are quite simple, but allow for an amazing wealth of functionality to spring into existence. Read this parable all the way through and you should have very little trouble mastering the various Git commands and wielding the awesome power that Git makes available to you.

For anybody still on the fence about whether version control is worthwhile, give The Git Parable a read to find out why most developers consider it a necessity. And even if you’re already familiar with version control it’s worth a read to get the basic concepts behind git (like that a commit it not a changeset, as in svn).

If it gets you curious to learn git, the free book Pro Git is the one book you should read. It combines straightforward, readable prose with clear diagrams:

Because Git uses a simple three-way merge, merging from one branch into another multiple times over a long period is generally easy to do. This means you can have several branches that are always open and that you use for different stages of your development cycle; you can merge regularly from some of them into others. Many Git developers have a workflow that embraces this approach, such as having only code that is entirely stable in their master branch — possibly only code that has been or will be released. They have another parallel branch named develop or next that they work from or use to test stability — it isn’t necessarily always stable, but whenever it gets to a stable state, it can be merged into master. It’s used to pull in topic branches (short-lived branches, like your earlier iss53 branch) when they’re ready, to make sure they pass all the tests and don’t introduce bugs.

This book is the best because Chacon finds the right balance between day-to-day interaction examples and exposing the underlying data model. It finds the right balance between “Don’t worry about this magic here” and “and now a discourse on directed acyclic graphs”.

And once you’ve read it, stop. You don’t need to read anything more about git, go forth and code.

Also Considered

The most common negative here is that a work is out of date: Git went from having almost nothing besides man pages from 2005-2007 to an explosion of introductory stuff in 2008 and early 2009. There were also a few significant UI improvements to git in late 2008 and through 2009 — so anything from before then will have a few confusing odds and ends, which is a problem when learning a system that’s already somewhat complex and opaque.

Git Community Book

A close second, the Git Community Book is only slightly less well-structured.

Version Control With Git

A little disorganized (there’s a lot of “X will be explained a few chapters from now”), but the O’Reilly house style you know well.

Git user Manual

Comprehensive and official, but no handholding, this is largely composed of man pages (…“which read like the terse mutterings of pilots wrestling with the controls of damaged airplanes”).

Pragmatic Version Control Using Git

Well-written and includes a nice reference to git-svn. There’s nothing wrong with this book, but Pro Git is newer and has great diagrams.

Learn Git

Well-written (it’s also largely by the indefatigable Chacon) but incomplete.

Git Internals

Scott Chacon’s first excellent introduction, great but less complete than Pro Git. I haven’t seen the screencast.

Git Magic

Fairly comprehensive, but it feels a bit too conversational and doesn’t explain behind-the-scenes fundamentals.

Git for Computer Scientists

“And now a discourse on directed acyclic graphs.” A short article on git’s data structures.

Git Ready

A friendly blog with bite-sized topics, appears defunct.

Randal Schwartz on Git

For too long this was the only beginner intro to git; by the Hooter’s guy.

Linus Torvalds on Git

A fun hour of Torvalds being rude and occasionally awesome, but not any real introduction.

Using Git Without Feeling Stupid One Two

Brief pair of blog posts giving a basic introduction

Git with Rails Tutorial

Outdated and only about deployment.

Understanding Git Conceptually

Basic info on branching, merging, remote repositories, but that’s all.

GitCasts

An outdated and defunct screencast blog.

Git the basics

A good 130m talk on git, but it’s all the data structures before the hands-on.

…and a few dozen other brief blog posts and talks that aren’t worth linking to.

(I chose The 4-Hour Work Week and Hacker News because they’re two very popular resources, but there’s dozens I could’ve chosen.)

I read quickly, I’m endlessly curious, and I have a completionist streak. I wish this formula worked, that somehow the process of absorbing and evaluating lots of different sources of information would make a successful business appear. I wish it more than you do. Last year I read scores of business books and blogs, screened dozens of hours of podcasts and videos.

These things contribute to business success, but there’s a point of diminishing returns that’s much nearer than I’d like to think. I’m glad I’ve read about prioritizing, delegating, and goal-setting, but The 4-Hour Work Week and No B.S. Time Management for Entrepreneurs are 90% the same material dressed in different writing styles.

Reading about a topic I already know something of is seductive. It’s easier to connect with other concepts in my head, I get the satisfaction of judging whether the author is proficient, I’ll cross another book off the list faster. And it’s sure as hell easier than fishing another case out of the issue tracker to fix a bug, add a feature, follow up with a contact.

The equation feels true but is a lie. It doesn’t much make my work better to keep reading instead of building. So in 2010 I’m building more and considering this business ‘research’ as the entertainment is is. We’ll see how it goes.

This annoyingly true aphorism has an important implication: an unfinished project, however close it seems to completion, is worth far less than a completed project. With that in mind, I’ve created a useful tool.

It is a text file named todo, and it appears as follows:

small todo:
  research thesauruses
  find a better launcher than fbrun
  finish jQuery Cookbook
  ~/.profile: print a random alias on login

sometime todo:

http://masanjin.net/sup-bugs/issue7

  get bike ready for spring
  tag and caption photos

business ideas:
  blog edit sharing - ask friends to preview a blog post
  online origami database
  ...

project ideas:
  roguelike: vampire in a town, hide and drain mob abilities
  patch MySQL to not allow blank WHERE in update/delete
  ...

purchases:
  bookends
  hat
  standing desk?
  measuring tape
  micrometer
  uninterruptable power supply

tv:
  House s5
  Mad Men s1
  Heroes s1
  Lost s1 (if it ends well)
  ...

games:
  World of Goo
  Dungeoneer (card game)
  ...

music:
  Bat For Lashes
  OK Go
  ...

[For boring historical reasons, the book/movie queue are elsewhere.]

Every time I have a brilliant idea to fix something or research a product to buy or take someone up on a media recommendation, I put it on the list. And every time I have a brilliant idea for a new project, it emphatically goes on the list so I don’t start working on it. (This is the hard part.)

When I’m going to relax, I’ll pick something off the list of media to check out. And when I happen to have the file open, I’ll occasionally move more-interesting items upwards and prune off anything uninteresting.

It’s neat to have the last couple years of game, business, and hobby project ideas collected in one place; the most interesting of them have a text file or a directory for notes and plans. I find that if I let myself spend a few minutes or hours pondering a project and then write it down, I can stop obsessing about it, perhaps because I don’t need to think of it to keep from forgetting it.

Success? Yeah, it helps. It’s unfortunately not a free Finish Everything You Start Ticket, but I’m coming to terms with their lack of existence. I’ve finished more in the five years I’ve been keeping the file than the five before and I’m tempted to attribute it to growing wiser and more experienced, except that keeping this file is one of the mechanisms that help me get wiser and more experienced.

Game designer and thoughtful critic Ernest Adams (his Designer’s Notebook column at Gamasutra is good reading) mused about an F2P developer’s presentation:

Zhan Ye explained in his lecture that in F2P game design, every feature must be measured by two metrics: is it fun, and does it make money? The designer is no longer free to concentrate purely on creating a fun game; the designer must be a businessperson. [...] The F2P business model seems a bit weird to me — it distorts what I think of as the designer’s main role — but it’s not wrong in and of itself, just different.

This reminded me a lot of a complaint from a graphic designer leaving Google a few years ago:

Yes, it’s true that a team at Google couldn’t decide between two blues, so they’re testing 41 shades between each blue to see which one performs better. I had a recent debate over whether a border should be 3, 4 or 5 pixels wide, and was asked to prove my case. I can’t operate in an environment like that. I’ve grown tired of debating such minuscule design decisions.

The industrial revolution – and especially the concept of scientific management – replaced the concept of craftsmanship with the efficiency of repeatable production. You can’t manufacture the creative work of ad copy, game design, or graphic design, but metrics allow businesses to know with industrial precision what works and doesn’t.

Every formerly creative decision is now an opportunity to be unambiguously wrong. Efficiency replaces autonomy.

Where it used to be possible to design things for design’s sake to meet a designer’s personal standards for quality, it’s increasingly easy for businesses to analyze the effects of even very small aspects of those designs. The designer is used to relying on personal taste, gut instinct, or professional standards to deal with the thousand small questions that crop up in every design, and it feels good to intuitively know the right answers.

The first thing everyone writes about metrics (like A/B tests) is that you’re going to be surprised how often your intuition is wrong, even on questions that seem obvious and easy to answer. The new (or newly accessible) metrics are immensely frustrating to designers for three reasons:

1. Analytics tools are one more damn thing to learn
2. that often reveal experience to only be assumption
3. and transform personal decisions into business decisions.

The valid argument I see against the intrusion of metrics is that they’re short-sighted, eg. a green button may increase sales 8% now but introduces an inconsistency in overall site theme that won’t be measured in the future. That’s hard to make when the web’s cheap distribution can give you millions of new opportunities for revenue in a matter of a few days or hours — or allow you to earn more than you thought off the very few you do have.

Designers are going to have to live with metrics trumping their professional experience and personal taste, at least whenever they work for a boss or investor. it’s not that this is a new awful trend, it’s that capitalism is redefining what it means to do design. The pursuit of profit isn’t strangling creativity, it’s changing what it means to be creative from achieving a singular artistic vision to experimenting and improving iteratively.

I love the way that poker straddles the line between the two. The contest of who has the best hand is indirect, I can’t take cards out of your hand, you can’t prevent me from drawing, we make our separate choices and win solely by ranking.

But betting is direct competition because players can choose to fold, can drop out rather than risk more resources. It’s a sprint where the players can’t see each others’ positions on the track, only claim “I’m at 40m” or “I’ve lapped you” and the truth of the positions are revealed at the showdown. Betting is a proxy for success, and bluffing is signaling a win when you’re actually losing.

Bluffing uses incomplete information to turn indirect competitions into direct competitions. I only know of Bullshit and Liar’s Dice that could be played without bluffing (and would then be simple luck games, like War).

Because I’ve been thinking so much about bluffing and in/direct competition, I’m tinkering around with a design for a poker variation that includes direct competition. I suspect it won’t be as much fun, indirect competition often leaves a losing player feeling they could’ve done won if they’d played a little differently. Please leave a comment if you know if any that already do or other games that play with similar mechanics.

• 1. Ikariam
• 2. WeeWar
• Tangent: The Farming Genre
• 3. Tactics Ogre
• 4. Counter-Strike
• 5. X-Com
• 6. Kongai
• Tangent: Technology Trees
• 7. Warstorm

Verbs

The fundamental difference between games and most other media is interactivity. When I want to understand a game, one step is to list all of the verbs available to the players. For example, the verbs in Super Mario Brothers are:

• Start 1/2 player game
• Walk left/right
• Run left/right
• Duck (when big)
• Jump
• Stomp enemy
• Kick shell
• Break brick
• Open question block
• Go down pipe
• Throw fireball
• Touch Axe

I was thinking of this because I played the browser-based trading card game Warstorm and I was astounded when I realized what the available verbs are on the site (ignoring the account management common to any site with user accounts):

• Edit a deck (“squad”)
• Auction a card
• Trade cards with a player
• Chat
• Challenge an individual player to a duel
• Enter tournament or league (tourney with restricted rule)
• Redeem loyalty points (given for interaction/marketing) for cards
• Buy Challenge Coins (premium currency)
• Play a duel

The first six verbs are common to any trading card game. The last item is the interesting one: play. It looks like I didn’t descend into the same level of detail I did for Mario, but I did.

The player selects which of their decks they’d like to use and the duel proceeds like War. The computer turns up the top card of each deck, applies their effects, and repeats. The only thing the player can do is fast-forward to the end to find out if they won or lost.

I was floored when I realized this, I thought the site was hollow. It’s all about a card game but there’s no game at its heart. It reminded me of gambling in that nearly every verb you invoke involves paying, but unlike gambling there’s no chance you’ll ever get any money back.

I babbled about this to my friends for a few days, trying to make sense of it. Eventually I realized I hadn’t seen where the game was hiding.

Decision Timing

In real-time games (rugby, StarCraft) players are constantly able to take action (maybe with asymmetrical actions, like the separate roles of offense and defense in American football). In turn-based games (Chess, Scrabble, Civilization) players alternate who is allowed to act.

Magic: The Gathering had clever game mechanics that gave players new actions in a preparatory phase called “deckbuilding” prior to playing cards (incidentally inventing a business model). The players make decisions about what actions they want available to them in the matchups.

Warstorm is designed so that all of the actions are up-front, there is no phase of the game besides deckbuilding. It didn’t feel to me like a game because no game mechanic involves direct interaction with the opponent, I didn’t see that I could ever make and change a decision in response to my opponent’s actions (unless we played multiple duels, I suppose). I didn’t even see the game because it was too different from what I was expecting.

But it made me wonder how business concerns drove the game design of Warstorm, a game where there’s little to do besides pay more money.

Business Concerns

When I turned my attention back to Athenge, I saw that my game design implied a lot of business decisions. I like games that require a lot of thought and analysis. I look at the most popular Facebook games and only see pastimes, idle toys requiring action with little thought, minimal direct competition, and even rarer losses. Oh, and tens of millions of players.

Warstorm reminded me that my taste in games is not common. Athenge will be a complex game, lots of instructions and options. It’ll take a lot of time for me, a lone developer, to build. Plus money to buy art, and more resources in marketing to find its non-mainstream audience. There’s risk to anything I choose to build, but Athenge looks to be more risk than it’s worth when I look at the current crop of simple, successful games. I could cut it down more and more, let these business concerns change my game’s design, but I’d rather let them replace my game’s design.

Instead of starting the programming of Athenge now, I’m continuing to improve the successful NearbyGamers and starting on a simpler, much more accessible game I’ve been tinkering with the design of for eighteen months. (Though it’s simple enough that’ll sound ridiculous when you see it, that’s fodder for another blog post). I still plan to build Athenge, but I think it must wait until I’m solidly in the black, until I’m not risking quite so much.

When you’re using one of these markup languages, you’re using HTML anyways. Because they must be translated to HTML to serve as web pages, at best they’re poor translations of HTML. A lot of them are “parsed” with regular expressions, leading to all kinds of interesting bugs with nested tags. MediaWiki (the engine behind Wikipedia) uses two apostrophes for ”bold” and three for ”’italic”’, and then just lets you use HTML for all the cases where these things break. Most markup languages have some passthrough like this to deal with ambiguity or complexity — so while some markups (not BBCode, which is like HTML in brackets) can claim to be easier to start using, users always end up learning HTML in the end.

MediaWiki actually has a decent argument for custom markup in its ability to build templates and fill in particular fields with data. These custom tags aren’t available in HTML, but there’s nothing stopping a site from adding its own tags (which may or may not look much like HTML) that are compiled down to HTML in the exact same fashion.

Some will argue security, that allowing raw HTML would allow people to perform cross-site scripting and other attacks, or include obscene images, or break the page layout, etc. I’m not arguing for letting users use HTML without filtering, it’s absolutely necessary. It’s difficult to protect against the wide variety of attacks, but being difficult doesn’t mean it shouldn’t be done. There are excellent whitelisting libraries available that remove any excuse about rolling one’s own, like Ruby’s Sanitize and PHP’s HTML Purifier.

If you’re building a site, let your users use HTML. A lot will already know it, there are a million free tutorials out there for them to learn it, and after using your site they’ll have a useful skill.

Watching Merlin Mann’s Inbox Zero video and reading the preceeding articles was the impetus for the final push to zero. It’s not that there’s anything I didn’t know in there. But there was the sense that it was not only possible but achievable.

So I immediately did what Mann suggested not to do and spent, oh, a full day changing email clients from mutt to sup. It sounds like an awesome amount of time-wasting, but I read the sup philosophical statement a while ago and it resonated:

The problem with traditional clients like Mutt is that they deal with individual pieces of email. This places a high mental cost on the user for each incoming email, by forcing them to ask: Should I keep this email, or delete it? If I keep it, where should I file it? I’ve spent the last 10 years of my life laboriously hand-filing every email message I received and feeling a mild sense of panic every time an email was both “from Mom” and “about school”.

The flip side of this is that once if you’ve set up automatic filters you have to remember to go check those folders, which is a habit I’ve never been able to form. And once I’ve ignored a folder for two weeks, hell, I’ll leave it another day or two, why hurry to find out if I missed out on something interesting or if I let someone down? Or three days. Or…

And so I’ve poured all of my email into sup’s index and started mercilessly hacking away at that last couple hundred messages I hadn’t yet dealt with. Read and delete, or archive, or note on my to-do list, or suck it up and start another email with “I’m sorry it took so long to get back to you…” And now it’s cleaned out, to my pleasant amazement.

There is, of course, the terrible chance I’ve missed something important, but I couldn’t let that risk of something getting lost in the upheavel continue to paralyze me. Perfect is the enemy of good. If you’ve been waiting on a reply from me about anything and didn’t get it in the last few minutes, I’m sorry, please let me know. And if you’ve thought about contacting me but haven’t because I did so poorly with the last few emails, I’m sorry, I’m going to keep trying to do better.