The Dangers of Prototyping
I came across a good article on prototyping
as I was reading about some of the reactions to the rumors that the
Nintendo Revolution hardware will not be capable of much more than the
current Gamecube hardware.
In my senior level software engineering course, my professor
discussed that one of the pitfalls that was associated with building
prototypes is that different audiences have vastly different
expectations and draw different conclusions from prototypes. For
example, an architect that builds a prototype to demonstrate a new
portal architecture doesn’t necessarily have to make the UI look
pretty. Other developers can appreciate the architectural design
elements such as how requests are handled, how state is handled, how
communication is handled between different components and so on.
But show it marketing or sales in the same state, and the project could
be dead in the water before it even starts, even though it may be the
best portal architecture ever designed.
I think Nintendo took a big risk by showing demos of the new
controllers in actions so early. While it was necessary to prove
that the new control schemes could work and work well, there is a
(mis)perception around the gaming community that the early prototypes
represent the final product in terms of graphical quality, even though
we currently have no idea what kind of hardware the demos were running
on. The average Joe looks at the graphics of the current gen.
hardware and then looks at the demos and will promptly proclaim that
the Revolution sucks without realizing the true level of innovation and
potential of the Revolution.
The article raises the question: “Is the Prototype the Production
System’s Ugly Sister?” Most of the time, yes. But in some
very special cases, the visual elements of the prototype, while they
may have no significant impact from a software engineering perspective,
become deal breakers:
The prototype does tend to be pretty ugly, and
deliberately so. Absolutely zero time should be spent trying to make it
look appealing. There are, however, a few notable exceptions to this:
- The prototype’s goal is to prove that a particular technology can be made to look good
(e.g. writing a GUI client with Java Swing). In this case, the
prototype would be more of a proof-of-concept, and would consist
primarily of GUI tricks and best practices to get the best out of the
platform and widget toolkit being used. In fact, you would spend less time concentrating on actual functionality, because that’s not the point of the prototype!
- The customer has difficulty distinguishing between form and function.
If this is the case, it sometimes pays dividends to spend a little
extra time making the prototype look good. Don’t go overboard
though—remember what you’re creating is going to be abandoned pretty
soon, in favor of a brand spanking new, shiny version with all mistakes
learnt (at least that’s the plan!)
- The prototype will also be used by Sales & Marketing, as an early sales pitch for your upcoming new product.
In this case, looks and shininess (the “ooh” factor) probably take
priority over real demonstrable functionality. Showing the customer
your impressive 20-megabyte auto-generated comma-delimited invoice file
might bore them faster than you think.
These are the exceptions, though. Most of the time, the prototype is
intended primarily as a means of gaining insight into the ideal
architecture, and is written in tandem with the design—before any
production code gets written.
I’ve bolded the portions that I found to apply to Nintendo’s current
situation. While I think that most people can understand that
those demos were really designed to show off the controller, they have,
nonetheless, inadvertantly relegated the Revolution to “has been” in
the minds of many gamers that have associated improved visuals with
“Next Gen”. So Nintendo has made the unfortunate mistake of not
making the demonstrations “pretty” enough, even though they were mainly
meant to demonstrate that the control scheme could work. Of
course, Nintendo can still blow us all away with XBox 360 level
graphics, but they’ve already lost the attention of a percentage of
hardcore gamers for whom graphical prowess is king.
The one thing to remember is that Nintendo has been working on this
next gen. hardware for quite some time now. There will be a new
CPU from IBM and a new GPU from ATI. I think the reasonable
conclusion is that the graphics for the Revolution will be significantly better than those on the Gamecube and first gen. games will likely be on par with first gen. XBox 360 games.