I’m a strong advocate of mobile developing, that is coding on highly mobile and interactive Tablet PCs or notebooks. Of course, there’s no doubt that these notebooks sacrifice power, but what you give up in performance and disk space, you gain in programming flexibility. You aren’t chained to a desk for all your coding. You can do it when and where you want and need. Another key benefit? A mobile programming platform also helps to keep the programmer tuned to the trimmed down platforms that many potential customers will probably be using–more specifically a growing number of customers will be using. This is particuilarly important for rich client oriented developers.
With all of this said, I’m suggesting a 180 here. I think it’s high time developers look at refreshing their desktop hardware. Why? Because we are on the verge of high-core systems. We’re not talking about dual core or hyperthreading here where one processor line might get essentially eaten up by an indexing service or anti-virus software or syncing content and the other the majority of your app. No, I’m talking 8, 16, 32, or more cores. And these multi-core systems are going to inspire a new set of possibilities. Developers need to begin to really dig into the issues and get familiar with what’s doable with this new hardware.
Now I’m not suggesting that all developers need to go out and splurge on a new desktop, but I think many should. Is it time right now? For some yes. Minimally developers ought to keep their eyes open for the next good deal on a great high-core system.
Here’s the deal. When there are a large enough number of cores available we’ll be able to develop apps that were never practical before. Now initially these apps may only run on desktops–which is a shrinking market–but eventually I imagine things will slide down into more devices. It seems that that’s where things are going.
The key here is that a very effective app that can leverage these many core systems is going to need to be coded up differently, breaking code into chunks or tasks that can be run side by side rather than only sequentially. Yes, we’ve had multi-threaded coding around for years, but with additions like C#’s forthcoming “Tasks” smaller chunks and more streamlined thinking are in hand. Up to this point, much of multi-threading programming on the desktop has been geared around doing things like making sure the UI doesn’t essentially lock up while performing some long task. That’s not what’s so exciting here. With the apps divided and coded up right, we’ll be able to see whole new apps and tools.
Here’s one of my favorites:
Vision processing. More and more computers are coming with webcams and these video streams contain lots of great information, but almost all of it is left unprocessed, because pragmatically today’s hardware can’t keep up. However, looking 5-10 years down the road, with 64+ core systems the game changes. Significantly.
Here’s a scenario: Imagine Rob Bushway is doing a live InkShow for Gottabemobile on some new super sleak Tablet eBook. Years back he’d probably sit in front of a single camera, record, edit and then post. With a large core system though he’s got more power at his disposal, which can result in doing more. For instance, he might use three webcams each pointing from a different vantage point. Further, two may be fixed although with high-resolution sensors that can software zoom on the fly withouth sacrificing noticable quality. The third camera might be on a motor driven book. That’s the camera side. On the software side there would be running a “director” app that follows instructions he’s given it on what he’s going to do in the InkShow and where the cameras should point, etc. The software does most of the rest to switch views and zoom in and out as necessary to keep what he’s planned in view. To accomplish this there’s a lot of processing going on–not only in pushing through all the pixels, but also in analyzing the streams for the intended content. Some might be automatic. Some human guided. Fantasy? We’ll see. Who knows. Some day we might see Camtasia Director :-).
Smarting indexing, better speech recognition, handwriting recognition, etc.
With a large number of cores, I imagine we’ll also see some new twists to APIs. Think of the possibilities with making the handwriting recognizer more flexible to simultaneous analysis. Maybe finally we will see multi-recognizers in OneNote: one for handwriting, one for shapes, etc.
My guess is that when Intel makes 16 core systems econmical and widely available, the time will really be ripe to jump into this new kind of coding. .NET 4.0 will be out by then and I imagine Apple will have its features too. Intel is already encouraging this segment of the market.
However, what about now? My recommended solution is the dual quad Mac Pro. It gives a fair number of cores at a reasonable price (though the memory is expensive), plenty of performance, good display support, and one other thing no Windows-only machine can do (well legally): a platform that can support Windows and OS X development.
As you know, I’m also a strong believer that just about all developers should be minimally watching and experimenting with iPhone/iPod Touch development and you need OS X for that. A Mac Pro dual booting or using Bootcamp or something like Parallels is the way to go. It gives you a great system for Windows and OS X/iPhone development.
Yes, you can go Windows only, but I think it’s better to keep your options open. That’s just my take.