1ft Startup

So Apple/KPCB has the iFund, Google has the Android Developer Challenge, and now RIM/Thompson Reuters is starting up their own BlackBerry fund. That sure feels like they’re trying to heat up the platform wars with pushing money to developers for very narrow goals. Who the heck would want to build a BlackBerry-only startup these days, except RIM?

The problem is that this doesn’t really promote solving any interesting problem. It is just the fragmented market continuing to compete with itself. A much more interesting direction would be to align investment pools perpendicular to this notion: Build a fund around location awareness, or mobile social networking, gaming, etc. That would do much more to unify the whole pie than this war over which handset gets the bigger slice.

We originally launched a little game called Mitosis nearly a year ago, as a cool experiment in what it would take to get a basic, unbranded game from nothing all the way through the door and as far as we can take it. Like most geeks, we’ve released very few of our own projects to commercial success, spending our time on other peoples’ projects for the actual cash.

If we were going to, say, write up the process of how we got Mitosis launched, it would look something like this:

- Build a cool game. The fun part. When you think you’ve got something good, you should consider the option to…
- Take it to an agent. We happened to know a few good people who could represent us to the carriers, otherwise we’d have languished out on GetJAR (more on that next time). Your agent will entice you with eye-popping (but un-guaranteed, of course) numbers. Your agent will also give you feedback from carriers, middlemen, basically whoever happens to be nearby, and if you’re lucky, you’ll eventually….
- Get reviewed by the carriers for deck placement. It takes MUCH longer than you think. Dealing with carriers is extremely slow; typically they have review processes that aren’t constant, but periodic: monthly, or even quarterly. If you’re one of the lucky, chosen few, you get to spend about 60 days to….
- Port your app. Foolhardy and spendthrift people that we are, we decided to do this in-house with the help of Device Anywhere. This is a possible option, but porting is never enjoyable. Do not underestimate how much work this is. It’s really a tedious and ongoing process, and some problems you simply can’t get around. Definitely take the time to streamline your build tools as much as possible, and you can survive to see the day that you…
- Get your builds certified. Like Verizon’s relationship with NSTL, T-Mobile now has a for-pay certification program with a company called True North. In our experience, their testing has been fair, and their test cases are reasonable; the true downside is simply that it’s up to the developer/publisher (depending on your agreement) to pay for the testing, and re-testing if you fail. That’s life! And now, there’s not much left to do but….
- Wait for it to show up in the catalog. Maybe we got lucky, but we ended up in some sort of deck-placement purgatory for many months while there was some sort of internal reorganization. Recently, finally, we launched on T-Mobile. Yeah!

Our important take-homes from this whole process:
- Publishing through carriers puts you at the mercy of many, many forces beyond your control.
- Decide what you want your company to be good at and focus on improving it.
- Don’t underestimate the pain of porting.
- The last 5% of the process can will drag on for months.

And most importantly, don’t forget why you’re doing what you are doing. We set out to have some fun, take a little break from our day jobs, and make some great games. And to be honest, we started to get burnt out by the actual business process. Once your game is out the door and in the hands of pre-teens spending their parents’ second mortage, though, there’s really no feeling like it.. And we may be just foolish enough to do it again.

The last title that we’ve done a fairly large porting effort on, Mitosis, was loaded OTA for testing / verification purposes 318 times. This isn’t even for development, just testing a feature-complete product on about 40 devices.

Russel Buckley says it’s nigh-impossible to do iterative development, and he’s right.. but the least you can do is work out some tools that make it as easy as possible. It’s really worth investing the time in a streamlined port management system for those device-loading cravings we all get.

If you’re managing a large site, building the WAP version of your site in a completely isolated environment is an appealing idea. It’s a business experiment, it doesn’t impact the daily site or put it at any risk, and it’s a quick way to get it up and running. This worked extremely well when I built the mobile site for a large news agency — News agencies are in the business of syndication, so they make their data extremely accessible. One of their web developers put it: You turn the tap on, and news is supposed to flow out.

So we launched our mobile news site, it was a huge success, and traffic started flowing in. Eventually, though, we started getting a few complaints that went like this: People were emailing articles to each-other from the web, and when they tried to click the link on their BlackBerries, they were redirected to the front page of the mobile site! They’d get a link from their friend, to:

news-site.com/article/25798470

And when they hit the link on their phone, they’d be detected as mobile and redirected to:

mobile.news-site.com

Not good! The same thing was also happening from users’ RSS readers. We did eventually fix this, but we had to set up some crazy redirects to take care of it (and unify some back-end data more tightly, so we could refer to the same article IDs).

The much cleaner approach would have been an integrated one, that (assuming a MVC model) simply displayed a different View while using the same Model/Controller.

A huge part of WAP consulting these days lies around ‘making the mobile version of my site.’ This is a great way to get things going quickly, but please do this with an eye toward eventually providing airtight site integration!

I was about to write an amendment to the previous post per Apple’s recent announcements about the upcoming SDK, but found a few people who already have similar thoughts and concerns. Remember that the iPod already has software developers building things for it, but it hasn’t been a huge codefest bonanza the way it was with, say, Palm software, because Apple has quite a tight grip on who they allow to develop for them and who they don’t (not to mention: they control distribution with the iTunes store).

Nokia and Apple are easily the dominant players in the new generation of high-end handsets. They’re both well poised to do something everyone in the industry has been dreaming of for years: loosening the stranglehold that the carriers have on content and open the market to crazier ideas. My money is on Nokia supporting those endeavors and Apple, well, not so much. I’d say that the great unwashed out here in reality are stuck with Java ME or web apps for at least the near future.. But I would be extremely happy to be wrong.

I was sitting in the Mobile Mondays NY meeting last week, listening to the SEO advice from the very level-headed guy at Google, and realized that everyone on stage was preaching what we have been trying to educate people on for years in the industry: WAP is different from the Web. It’s really different. You can’t just point people at your .com site and expect their phones not to crash, you need to accommodate users in ways you never have before. At its easiest, this just means directing them to a watered down site with a few pages of text, but if you’re really serious about it, this means building a fully adaptive site that scales its images, custom-tailors its stylesheets (or lack of), and even completely changes the markup from WML to XHTML-MP to CHTML.

That’s what we’ve been preaching for years, and it’s finally about to become irrelevant.
About a million iPhones are out there around now, and growing fast. Maybe even more Nokia N95s or other extra-smart gadgets are out there. Some of the new phones can’t even read WML, but they all execute Javascript like nobody’s business. They’re normal browsers.. nearly. Over the last week, potentially thousands of users stopped going to the mobile-specific sites and started going directly to their usual desktop web sites. Even more people browsed the web for the first time ever on their phones.

What does this mean for the mobile web as we know it so far? Is it so niche that it’s not even worth looking at, because it’ll be so overtaken by users with smart devices that it will become invisible on the radar?

Probably. The mobile web will never be as complicated as it is today. It’s a patchwork of support, where when you evaluate the characteristics of one device, you add support to about 0.8% of your customers. The mobile web sites have been outsourced to development companies that build a mobile-friendly version of the site, usually completely decoupled from the real site, with its own revenue streams. Soon, all you’ll need is a separate stylesheet, if that.

It’s hard to say it, but we knew the day would come: WAP as we know it has peaked and the days of a totally different mobile site will be on their way to the dustbin.

This doesn’t mean that mobile web development will die, it will just become far simpler. I still don’t believe that a page designed for a 19″ display will ever be desirable on a 3″ display, but that’s easier to fix: Most of the changes will be doable with the same content, with a separate stylesheet (incidentally, why doesn’t the iPhone respond to the ‘handheld’ CSS media type so that you don’t have to do any detection at all?). In the meantime, though, those of us who fought for years to explain the dire difference between the two worlds need to adjust our tunes.

One of the major differences between mobile code and desktop code is the severe number of SKUs (that is, variations on the build) that you have to support to make a dent in the customer base. Device support is a truly a long tail; after a couple hundred devices you’re getting close to about 80% of the market.

The biggest problem with J2ME in this case is that, unlike the desktop/PC world of Java, the VMs are built by MANY groups with different interpretations of the spec. Even if that weren’t the case, you’re trying to support some very different hardware characteristics: memory, screen resolution, network limitations, storage, etc.

All this means is that if you want your app to be a success, you’re going to adapt your code to support hundreds of phones.
Ugh.

What’s a developer to do? Here are a few basic points that work for me:

• Stay Organized. This should go without saying, but make a concerted effort to keep your builds clean, repeatable, and stowed away well. Someone will be asking you to send them the latest working build for their Motorola C290, and you should always have it handy. Do one of these:
  • Keep a folder heirarchy for your compiled files. Mine looks like:

    ->Builds
       -><app name>
           ->Version (e.g. 0.9.4)
               ->Screen Size (e.g. 176x220)
                    <standard build>
                   ->Custom build 1 (e.g. Nokia Series 60)
                       <build>
                   ->Custom build 2
                    ...
    

    For a solution like this, you’ll need a handy way to look up capabilities to help you dig out the right build for a handset.

  • Build/adapt a simple CMS. If you’ve got some time, this is the best option you’ve got (we’re working on a new one we may be able to share with you, stay tuned). You’ll thank yourself later.
• Write reusable code. Write with the intention of building what you write into a framework. OK, this will probably net you a few more KB in code, but it will save you from hurting yourself over and over again. Write as few new lines as you possibly can in a new app. Every time you fix a handset-specific bug, you’ve fixed it for everything you ever write in the future. In fact, if you’re really pathological, you can extract basically everything out of most apps into your own scripting/markup language and build your apps without writing a single line of real J2ME code. Sounds like a lot of work, not not nearly as much work as supporting two dozen codebases.
• Don’t use the APIs. Really. Do it yourself. The reasons for this tend to fall into two categories:
  • Lack of control. Generally, more advanced apps don’t make use of the standard javax.microedition.lcdui.Form drawing mode for professional apps, and definitely not for work-for-hire (Try explaining to a client that there’s no way you can change the title’s background, see how they react!).
  • Lack of bug-freeness. Think it’s handy that you can change the color of a font and write it to a virtual buffer? The original Nokia Series 60s didn’t think it was useful enough to support. Get in a habit of wincing every time you take advantage of another cool GameCanvas feature to your code. Sorry!
• Use a preprocessor. Java/OO purists are going to hate this, but the Java purists must hate quite a lot about J2ME. Use a preprocessor (like the one included with antenna) to build code that works against different handset sizes and capabilities.
• Use the JAD properties to tweak your code. This is far easier to manage than a total rebuild. Take advantage of the JAD properties for simple differences in builds, such as softkey codes, sound characteristics, timers adjusted to the speed of the handset, etc. Again, you’ll be sacrificing a little code size (and maybe a tiny bit of speed, in some cases), but seriously.
  

Certain tedious tasks come up all the time that are unique to the mobile dev world. One of those things is digging for information about phone capabilities (screen dimensions, feature support, etc). There are plenty of sites that handle this in some capacity (my favorite is Phonescoop), but as with all sites that aren’t your own, sometimes they just take you 80% of the way there and leave you wishing you had just one more button in just the right place.

I needed something a little more efficient for quick, capability-based lookups, to I threw this tool together:

http://devices.theoreticlabs.com

This is my first Ruby on Rails project (running on mongrel, yeah!) so there’s bound to be some wackness, but it works for ma; actual mileage may vary. It’s built on top of the excellent-for-its-price open source handset capabilities database, WURFL. Enjoy!

I wanted to preface this entry with where we left off last year: Hope is not lost for the weekend-warrior mobile game developer! Here are some upsides to try to make you feel better after losing all will to carry on in our last episode:

Mobile games are lo-fidelity. The point here is that it doesn’t take a multimillion-dollar studio to make a game that can compete on a level playing field with everyone else in mobile (yet!).

Distribution isn’t as hard as it looks. Installation is automatic for J2ME apps, so no need to hassle with installers, and there are plenty of sites dedicated to getting a very international distribution for your games. (What kind of volume this actually provides, well, I’m figuring that out now. More on it later)

These are still pretty early days in mobile. The small guys haven’t quite been pushed off the playing field. Most mobile game still really suck (even from the big shops), so if you can do something that’s not a painful, crashing eyesore, you’ve got a decent shot.

Mitosis Launched!

So, since the dawn of time (about 7-8 months ago), Theoretic Labs has been about consulting and helping our friends out with their startups. On the “side” however, we have been working on a LOT of other projects. A few of them will come to fruition in the next few weeks, a few more will come in the months following.

I’m really very excited to announce the first of these, which is a simple game called Mitosis. The basic premise of the game is actually hard to articulate concisely in text, but really easy once you play it for a few seconds. You play the colored cell on the bottom of the screen, and shoot down the incoming cells from the top. You can only destroy the ones that match your color, and if you shoot one that does not match, you’ll swap colors with that cell. Think Zoop (which apparently nobody remembers but me), but simplified angles of play and a little more disgusting.

Why Can’t Anyone Play Mobile Games Online?

I was surprised to find that nearly nobody has a “try this game online for free” type feature for their cell phone games. It seems that this is because it’s really hard to find a decent MIDP 2.0 emulator that runs as an applet in the browser. The closest the real world has got is a handful of commercial products, and a broken open-source one called ME4SE. Well, it turns out that ME4SE isn’t too hard to fix, so I did it for the release of this game. Try it here! I’ll find a way to reapply these fixes back to the OS community after I clean it up a bit.

As a total aside: I know that Java has really lost this web-application technology fight to Ajax and Flash by squandering their early lead with the most spectacular array of installation and execution bugs seen since, well, forever. But please, Java, don’t go away on the web, I need you for an emulator! You can still fix the mess you’ve made.

Mobile Distribution

Our first distribution partners are the low-hanging fruit for indies, Greystripe’s super-clever AdWrap service and ClickGamer, for the more traditional purchased format. We have some people working on our behalf to get our products under the noses of the carriers as well, so with any luck that will pan out in short-ish order.

It’s probably too early to comment on how it’s been working out with these partners so I’ll hold my tongue, but rest assured that will come soon!

There are two major real-world reasons that the shoestring development world for mobiles is rather more difficult than traditional startup software development:

1. Broad phone support is nigh-impossible on a low budget.
   
   First of all, any BREW phones are right out the window: Qualcomm’s BREW platform is prohibitive to small fries, because they have a strict, expensive testing process for any app to be ‘approved’ for a particular handset/carrier, and customers with BREW phones can only install apps that their carrier makes available. This means you’ll need to recoup thousands of dollars in testing costs, as well as hire someone to manage carrier relationships (or do it yourself, you poor bugger). This model effectively cuts out everyone who’s working from a garage, or anyone who wants to give their app away for free.
   
   So that leaves us with Java ME as the other major platform. Java ME is, of course, sweetly intended to be a “Write Once, Run Anywhere” platform, but the KVM authors are all have their own eccentric disloyalty to the spec. This is the kind of thing that an outside observer wouldn’t believe to actually be a hindrance these days, I mean, it’s the year 2000 and hey, we’ve got flying cars! Alas, it’s truly amazing how cracked out some implementations can be. Coding errors aside, there are intrinsic differences in the handsets’ actual, physical capabilities anyhow: Screen dimensions, resource constraints, whether the phone has a Clear key, etc. These attributes must be addressed across thousands of devices regardless.
2. People buy new phones more often than they buy new underwear. This is really an amendment to the first statement, because it causes two sub-problems:
   1. Your app may not work on their new device, and therefore:
   2. You must test new devices eternally.

   You can still install a good chunk of shareware from the Windows 95 days on a new Vista install without much trouble. Even if you couldn’t, it seems that the replacement rate of phones far outstrips that of computers (though I don’t have numbers for that one… lazyweb?), so people are likely to be making better use of their older apps and older OSs on their computer than on the phone.
   

In this environment, it’s extremely unlikely that we’ll see something similar to the runaway successes that we’ve seen in shareware, selling apps and games that scarcely need updating in a decade to keep doing well for themselves. While the shareware makers on the desktop are kicking back on their porch sipping lemonade and responding to fanmail, all us mobile indies have got the Sisyphusean task of sneaking into the Cingular store to test our apps on the hottest new Nokia.

I hate to leave off here on a down note, but I will be back soon with the more interesting upsides, and how to get rid of at least some of the pain that plagues us.