While I absolutely agree with his primary conclusions…

“The era of the PC’s dominance is officially over.  We have crossed over into the age of mobile computing.”

and

“I’m not saying we won’t still have desktop computers.  But if you’re looking for the real action, the exciting innovations, it’s going to be in mobile from now on.”

… I can’t quite get on board with his assertion that the clear signal of this transition was Microsoft’s recent Windows Phone Series 7 announcement.  Instead, I think that most of us recognized the transition about the time that the iPhone hit 20M units.  By then, nearly everyone that we knew either had one, or was getting one.  Almost every major handset vendor had announced at least one “iPhone killer” and tens of thousands of us suckers were rushing to develop apps.  At that point, we saw iPhone use spanning all demographic groups, and people genuinely loved them (enough to put up with AT&T’s network).

Let’s face it, Apple may not be the dominant player in the long term, but, as they have so often before, they brought fascinating technology to the mainstream.  The truth is that nobody else could pull it all together in a compelling package.

Still, if you have any doubt that the future of computing is mobile, please go read Mr. O’Brien’s column.  If you still don’t believe it, consider that my 77 year old father is the very happy user of a new iPod Touch.

A good portion of my foundational thinking about mobile computing comes from meetings that we had with Jeff Hawkins, back in the Palm Computing era.  Mr. Hawkins’ stories about carving a block of wood until it fit in his shirt pocket have stuck with me.  As the story goes, that block became the model for the early Palm Pilots.

That’s exactly the point.  Until we have some kind of implants that connect us directly to the data flow, I want the following things in my device (in order of priority, but these have pretty much all been show stoppers):

• It fits in my pocket — otherwise it won’t be with me enough to be effective.
• As a corollary to the above, it is light enough that I don’t mind packing it pretty much all of the time
• The software that I use runs on it
• It has a high bandwidth connection to the Net
• The UI is accessible for me
• It functionally replaces other things that I carry.  A few years ago my briefcase held a notebook computer, a cell phone, a PDA, a pager and a few kilograms of cords / chargers / cables.
• It lasts through, at least, a full day of normal use without recharging (my iPod touch can’t do this if the 802.11 radio is active)

My dream has always been to have one handheld device for most activities, along with, maybe, a netbook/ultra portable laptop that I could drag along if I planned to do heavy text entry (I’m fine with Graffiti, and I’ve come to quite like the soft keyboard on my iPod Touch).

Finally, getting around to my point, I’ll gladly spend whatever I have to in order to get a device that meets my criteria and runs on a reliable network.  I’m certainly not, however, going to spend several hundred dollars for something that’s inconvenient to carry, no matter how beautiful it is.  Beauty and functionality are useless to me if the device is sitting on my desk when I’m out and need to connect.  At that point, a tablet is about as useful as my first Mac 128K (long since recycled) would be.

As far as I’m concerned, the iPhone 3GS and the Google Nexus One are as close to my ideal device as we have right now.  Perhaps I’m just dense, but I don’t understand why the tablet is the subject of such breathless anticipation.  I’d much rather have Apple devote its considerable engineering talent to making the iPhone even better.  They’re almost there…

My thoughts follow along lines similar to the reasoning in John Boyd’s recent post:

“… the smartphone experience is rapidly becoming mass market and main stream and as that trend continues, people will want more choice, more hardware and performance. In short, in early cycles, Apple’s strategy of control is usually going to be superior but as a technology becomes mainstream, it fails.

We’ve seen the model for this in Apple’s early years, where people favored Apple over the PC. People thought Apple was unbeatable but they were eventually driven to the point where people started looking at the cash value on the balance sheet.

Eventually as people became comfortable with the PC World, they didn’t want to be controlled anymore. Even the least savvy technical users wanted more choice in hardware and applications as their comfort level rose.”

I love what Apple has accomplished with the iPhone, just like I loved my first Mac 128k (no hard drive, just the floppy).  However, I’m afraid that the challenge presented by the diverse teams contributing to the Android+hardware ecosystem will simply be overwhelming. 

The aforementioned HTC Passion, based on a 1 GHz Snapdragon, is just the latest example of how fast this juggernaut is moving.  With iPhone OS as a template, and the vast resources working on Android+hdw, the solutions will evolve quickly and will pass the “good enough” mark in very short order.  Given its relative carrier independence, Android+hdw will absolutely present a challenge to the iPhone hegemony.

According to AppleInsider, the launch resulted in just 5K new subscribers for China Unicom.

Another story suggests some of the reasons for the “soft” launch.  Although the reporter is still optimistic about the iPhone’s future in China, the excuses include:

• It’s too expensive.  No kidding — US$1,024 for a crippled (w/o 802.11) 32GB 3Gs
• No Wi-Fi (apparently it’s coming in a future version of the device)
• Everyone who wanted one already had a gray-market iPhone.  I’m guessing that this, coupled with China Unicom’s policy of just letting current owners legally activate on the network, was a big factor.

For what it’s worth, we haven’t sold a single app in China since the launch…

Image Credit:  Demotivation.com

AdMob chose to highlight the following results:

• Android and iPhone users download approximately 10 new apps a month, while iPod touch owners download an average of 18 per month
• More than 90 percent of Android and iPhone OS users browse and search for apps directly on their mobile device instead of their computer
• Upgrading from the lite version was the top reason given when users were asked what drives them to purchase a paid app
• iPhone and iPod touch users are twice as likely to purchase paid apps than Android users
• Users who regularly download paid apps spend approximately $9 on an average of five paid downloads per month

As the proud user of an iPod touch, I was thrilled to see that my fellow touch users are, by far, the most prolific downloaders:

There are a couple of interesting things about this chart.  First, it should probably be titled, “Avg. Downloads per User per Month,” but that’s nitpicking.  The other thing that caught my attention is that, while iPod touch users are nearly twice as productive (or perhaps counter-productive, depending on whether you’re their employer) as iPhone users in terms of downloading apps, they are much less likely to pay for their apps.  Nearly 25% of the iPhone apps are paid, while just over 10% of the apps on touches are paid.  This is another reminder that the user communities are not at all homogeneous across the two devices.

For this post, I’m going to focus on the iPhone / iPod touch.  Although the report also covers Android, at this point, I’m more interested in the results for our target platforms.

In going through the report, I noticed a couple of other bits that are likely to influence how I conduct campaigns for BluMtnWerx.  For example, the top three ways that users discover apps are, in order:

• Browsing through top App Store rankings
• Searching for a specific type of app
• Word of mouth (recommendations from friends or colleagues)

They also asked people who downloaded at least one paid app / month, “What Usually drives you to purchase a paid app?”  I guess that I shouldn’t be surprised, given some of the experiments that developers have conducted, but the top reason was (emphasis mine):

“I like the free version and upgraded“

I sure wish that Apple would approve iPuckLite!  It’s been waiting for nearly a month, now.

By contrast, the bottom two were:

• News articles or blogs
• A brand I know reaches out to me and introduces an app

Clearly, this reinforces the notion that getting high rankings in the App Store is the ticket to success.  It might also suggest that the effort put into blogging & self-promotion may have less impact (so why am I writing this?).  When I think about the results, though, I wonder whether the grassroots blogging and outreach are actually necessary prerequisites for getting good rankings on the App Store.

One place where the sample bias in AdMob’s methodology really comes through is the #4 item on their list:

“Seeing ads while using other apps”

The report contains some extremely interesting data on daily usage of apps.  Apparently iPhone users spend, on (weighted) average 84 minutes/day using apps, while iPod touch addicts are tapping away for 121 minutes/day.  The most fascinating thing in that data set, though, was the report that 21% of iPod touch users spend More Than Four Hours each day stabbing at their screens!  I don’t know whether to feel happy, or sad, if that’s true.

Finally, AdMob did some back of the envelope calculations to conclude that the App store paid market is currently (August 2009) about $200M per month.  Stunning.

Even if you don’t like AdMob, you really should spend a few minutes evaluating the information in this report and considering how it might impact your business.

Here’s the effect I was trying to achieve:

What we have here is the iPunt playing box suspended in mid-air. The floor is a broken mirror (although that’s a little hard to see from this angle.) The camera is allowed to move freely around the inside of the skybox. When the camera is below the foor, the floor appears transparent (like broken glass.) The walls of the playbox are fractured glass.

The problem, really, is the reflection. Without any stenciling, you get this…

We somehow need to prevent the reflected scene that is not viewed through the mirrored floor from showing. A stencil buffer would have worked well for this purpose. Without a stencil buffer, you have to rely on depth culling and transparency to achieve the desired result.

In brief, what I did was to create a stencil shape (a planar shape made up of triangles) that had a hole in the middle where the mirrored floor was going to be and was large enough to obscure the reflected scene from all camera angles above the plane of the floor. This shape will be drawn transparent (alpha = 0) so that the skybox will show through, but the draw order and the depth culling will prevent the unwanted portions of the reflected scene from showing through.

Here’s a picture of the skybox, reflection, and stencil (with the alpha turned up so that it can be seen.)

Because the draw order is skybox, then stencil, then reflected scene, those portions of the reflected scene that are occluded by the stencil are depth-culled and won’t be drawn. The real scene and floor can then be drawn.

Here is the code, with comments, that does this…

First, the definition of the stencil and floor triangles.

// The shape here is a large plane
// with a hole in it where the mirror will be.
const GLfloat stencilVerts[] = {
-100.0, -15.0, 100.0,
-10.0, -15.0, 10.0,
100.0, -15.0, 100.0,
10.0, -15.0, 10.0,
100.0, -15.0, -100.0,
10.0, -15.0, -10.0,
-100.0, -15.0, -100.0,
-10.0, -15.0, -10.0,
-100.0, -15.0, 100.0,
-10.0, -15.0, 10.0
};

const GLfloat floorVerts[] = {
-10.0, -15.0, 10.0,
10.0, -15.0, 10.0,
10.0, -15.0, -10.0,
-10.0, -15.0, -10.0,
};

const GLfloat floorUV[] = {
0.0, 0.0,
0.0, 1.0,
1.0, 1.0,
1.0, 0.0
};

Then in my render() function…

  glEnable(GL_DEPTH_TEST);
  glEnable(GL_TEXTURE_2D);
  glShadeModel(GL_SMOOTH);
  glBlendFunc (GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

  // Clear the space
  glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  CHECK_ERR

  // Draw the skybox
  _pSkyBox->draw();
  CHECK_ERR

  // Only draw the reflection if the view is above the plane of the floor.
  if (pWorld->camera()->location().y() > -14.5) {

    // Draw the stencil.  Anything that is drawn after this that is occluded by the
    // stencil will not be drawn because it fails the depth test.  The skybox, which
    // has already been drawn, will show through everywhere because of the transparency.
    pWorld->material("StencilMaterial")->installMaterial();  // Sets the material properties, including alpha
    glEnableClientState(GL_VERTEX_ARRAY);
    glVertexPointer(3, GL_FLOAT, 0, stencilVerts);
    glDrawArrays(GL_TRIANGLE_STRIP, 0, 10);
    glDisableClientState(GL_VERTEX_ARRAY);
    pWorld->material("StencilMaterial")->uninstallMaterial();

    // Draw reflection w/out floor -- Reflection will be depth culled everwhere but hole
    // Draw everything else normally (including the mirrored floor)
    glPushMatrix ();
    // Mirror lies in XZ plane, so scale by -1.0 in Y axis
    glScalef(1.0, -1.0, 1.0);
    // Mirror is 15.0 units from origin, so translate by 30.0 units
    glTranslatef(0.0, 30.0, 0.0);
    pWorld->draw();
    glPopMatrix();
  }
  CHECK_ERR

  // Draw the real scene
  pWorld->draw();
  CHECK_ERR

  // Draw the floor
  BMWLight::disableLighting();
  pWorld->material("Material_010")->installMaterial(); // Sets the material properties
  glEnableClientState(GL_VERTEX_ARRAY);
  glVertexPointer(3, GL_FLOAT, 0, floorVerts);
  glEnableClientState(GL_TEXTURE_COORD_ARRAY);
  glClientActiveTexture(GL_TEXTURE0);
  glTexCoordPointer(2, VERTTYPEENUM, 0, floorUV);
  glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
  glDisableClientState(GL_TEXTURE_COORD_ARRAY);
  glDisableClientState(GL_VERTEX_ARRAY);
  pWorld->material("Material_010")->uninstallMaterial();
  BMWLight::enableLighting();

Note that the BMW functions are functions in our framework that encapsulate OpenGL functionality. You can pretty much treat them as pseudo-code in this example.

So, there you have it. A use of depth culling and transparency to implement functionality that I originally though required a stencil buffer. I’d be intereste in hearing about any examples you have of similar effects!

… it’s hard not to wonder what kind of magic pixie dust Apple dropped into its devices. The iPhone has created a monumental divide between its products and others on the market, especially other smartphones.

Mr. Berg continues:

From the way carriers manage their networks to mobile content distribution, the iPhone is setting standards that will last long after other devices come along and even out the playing field.

This is why I’ve been so hard on Palm.  They apparently did a good job with the Pre and webOS, but they simply failed to understand the significance of the App Store and the iPhone development ecosystem.  I feel sorry for them, but they just don’t seem to appreciate the points that Mr. Berg makes in his article.

I guess that it’s true: “The more things change, the more they stay the same.”  Apple continues to innovate and lead.  Others continue to follow.

 
——–
Technorati Tags:  iPhone, iPod Touch, Apple, mobile

It’s definitely been a new frontier for me.  After years and years of large application development in the computer aided engineering fields on *NIX and Windows platforms, much is new:

• The Mac development platform
• Objective-C
• 3D Graphics
• Small, lightweight programs
• Touch UI
• A different kind of user

My bookshelves are full of books that are not relevant.  My office has 4 Windows machines and 2 Sun Ultra-Sparc Solaris computers.  I obviously have a major transition to make.  But, I know how to develop quality software.

To bootstrap ourselves, Dean and I did a lot of up-front reading.  There are many helpful blogs out there for newbs like ourselves.  One we found particularly useful is by Craig Hockenberry over on furbo.org .

Step 1 — Sign up on the Apple iPhone developer site and start reading.

This step was easy.  There is a wealth of information on the Apple Developer Connection web site.  I spent some serious time with the materials on the web site relevant to the Cocoa SDK, the iPhone software architecture, Objective-C, and XCode.  I’ve spent 20 years with C++ so Objective-C looks pretty weird, but I can certainly understand the motivation for some of the differences.  Apple has definitely built themselves an island with this one!  (Later I learned that I can use Objective-C++ and I now feel right at home.)

Step 2 — Buy a Mac.

After spending some serious time on eBay, I found a Buy It Now Macbook with 13" display, 2GHz, and 1GB of RAM for $650 with shipping.  I’m used to buying cheap Windows laptops, so the cost of a Macbook was a bit shocking (I saw a Macbook Pro that had had Gatorade spilled in it go at auction for over $700!) but $650 was certainly acceptable.  When I received the Macbook, it was nearly pristine.  In fact, I am so happy with the quality and rapid service that I want to put in a plug for Beta Macs in Denver.  Check out their eBay store as well if you’re looking for a Macbook to get started with.

I read that for development at least 2GB of memory was advised, so I picked up 4GB of RAM from Tiger Direct for $50 along with a 250GB 2.5" USB drive for extra storage and backups.

The Macbook was instantly loved at our house.  My 12 year old daughter now wants one, even though she has a Gateway dual-core X64 Windows laptop that she uses.  My 16 yr old son thinks it’s cool and likes Garage Band.  I like it, and I especially like having the Bash command-line and *NIX functionality at my fingertips without loading CygWin.  In fact, I’m totally in love with Mac OS-X for that reason.  Basing it on UNIX was brilliant.

Step 3 — Download the iPhone SDK and watch videos.

Downloading and installing the iPhone SDK was a breeze.  I also spent most of a day watching the iPhone tutorial videos on iTunes.  This is time well spent just to learn all the new terminology.

Step 4 — More Research.

One of the first applications I want to develop is a game where I’ll be employing some 3D graphics.  As I looked at OpenGL-ES and the rest of the SDK, it became apparent that the graphics SDK was pretty primitive (Cocoa has lots of the stuff you need for UI programming, but OpenGL is just a ‘C’ API and definitely needs some OO stuff around it.)  Before I tore off and re-invented the wheel, I did some research to see what others have done.  Here’s what I found:

• OpenGL C++ Toolkit – A C++ library and toolkit for OpenGL.  Probably couldn’t be used "out of the box" but could probably be ported without too much trouble (if it hasn’t happened already).
• Open Scene Graph – An Open Source scene graph SDK for OpenGL.  Looks very powerful and, again, could probably be ported in whole or in part.  Significant overkill for the applications I’m currently imagining.
• Oolong iPhone Game Engine — Now we’re talking.  A 3D graphics toolkit over OpenGL ES, based on the PowerVR SDK , with the Bullet physics library integrated.  (Note that this effort is still pretty young, so there isn’t a lot of documentation with the kit, but it is usable.  Be sure to also download the PowerVR SDK for both the tools and documentation.)  The jury is out as to the performance of this beast on the device, but it is a great starting point.  I hope to contribute to the project over time.

With Oolong, I think I’ve found the giant I want to stand on.  I’d much rather contribute to an infant effort than re-invent the wheel.

Step 5 — Setup a web site.

This obviously doesn’t get us any closer to having an iPhone app, but Dean and I felt it important to get a blog, web site, and source code management system setup as early as possible.  We’re both most familiar with CVS (I’ve used it for over 15 years) but decided to go with Subversion for it’s features.  I can setup a CVS repository on a server in about 5 minutes.  Setting up Subversion took me a long time.  It seems to be working well, however, and we’ll see how things go long term.  We can always fall back to CVS if we need to.  If you need pointers on setting up Subversion on a Plesk managed server, maybe I can help.  It wasn’t as hard as I made it!  The XCode integration looks pretty good, and I dowloaded a trial copy of the SmartSVN client as well for it’s tag and branch features.

The web site is simple at this point.  We’ll be expanding it as we have applications to push and things to share.  This blog will be our primary means of communication.

Step 6 — Start coding.

Yeah!  Finally.  After some serious coding, I’ve decided I really like XCode.  I haven’t poked into everything yet, but I’m getting the hang of it and it’s working really well.  Most of the coding I’m doing right now is in C++ around OpenGL and Oolong.  Results are coming fast now, although I still have a whole lot to learn before I’ve got a complete application.

Next Step — Acquire a device.

Yep, haven’t done that yet.  Right now I’m running in the simulator which works pretty well but doesn’t give you the feel of the device at all, especially for accelerometer stuff.  Even the touch interactions are very different.  I’m particularly concerned about the performance of Oolong given all the floating point computations.  I should have a device (I’m starting with an iPod Touch) next weekend, and then I’ve got to pay my $99 and get the provisioning stuff together.

Lots to do, but I’m having a lot of fun!  Makes me feel young again.

paul