Tech Predictions, 2011 Edition

Long-time readers of this blog know what’s coming next: it’s time for Ted to prognosticate
on what the coming year of tech will bring us. But I believe strongly in accountability,
even in my offered-up-for-free predictions, so one of the traditions of this space
is to go back and revisit my predictions from this time last year. So, without further
ado, let’s look back at Ted’s
2010 predictions, and see how things played out; 2010 predictions are prefixed
with “THEN”, and my thoughts on my predictions are prefixed with “NOW”:

For 2010, I predicted....

• THEN: ... I will offer 3- and 4-day training classes on F# and
  Scala, among other things. OK, that's not fair—yes, I have the materials, I just
  need to work out locations and times. Contact me if you're interested in a private
  class, by the way.
• NOW: Well, I offered them… I just didn’t do much to advertise them
  or sell them. I got plenty busy just with the other things I had going on. Besides,
  this and the next prediction were pretty much all advertisement anyway, so I don’t
  know if anybody really counts these two.
• THEN: ... I will publish two books, one on F# and one on Scala. OK,
  OK, another plug. Or, rather, more of a resolution. One will be the "Professional
  F#" I'm doing for Wiley/Wrox, the other isn't yet finalized. But it'll either
  be published through a publisher, or self-published, by JavaOne 2010.
• NOW: “Professional F# 2.0” shipped in Q3 of 2010; the other Scala
  book I decided not to pursue—too much stuff going on to really put the necessary time
  into it. (Cue sad trombone.)
• THEN: ... DSLs will either "succeed" this year, or
  begin the short slide into the dustbin of obscure programming ideas. Domain-specific
  language advocates have to put up some kind of strawman for developers to learn from
  and poke at, or the whole concept will just fade away. Martin's book will help, if
  it ships this year, but even that might not be enough to generate interest if it doesn't
  have some kind of large-scale applicability in it. Patterns and refactoring and enterprise
  containers all had a huge advantage in that developers could see pretty easily what
  the problem was they solved; DSLs haven't made that clear yet.
• NOW: To be honest, this one is hard to call. Martin Fowler published
  his DSL book, which many people consider to be a good sign of what’s happening in
  the world, but really, the DSL buzz seems to have dropped off significantly. The strawman
  hasn’t appeared in any meaningful public way (I still don’t see an example being offered
  up from anybody), and that leads me to believe that the fading-away has started.
• THEN: ... functional languages will start to see a backlash. I
  hate to say it, but "getting" the functional mindset is hard, and there's
  precious few resources that are making it easy for mainstream (read: O-O) developers
  make that adjustment, far fewer than there was during the procedural-to-object shift.
  If the functional community doesn't want to become mainstream, then mainstream developers
  will find ways to take functional's most compelling gateway use-case (parallel/concurrent
  programming) and find a way to "git 'er done" in the traditional O-O approach,
  probably through software transactional memory, and functional languages like Haskell
  and Erlang will be relegated to the "What Might Have Been" of computer science
  history. Not sure what I mean? Try this: walk into a functional language forum, and
  ask what a monad is. Nobody yet has been able to produce an answer that doesn't involve
  math theory, or that does involve a practical domain-object-based example. In fact,
  nobody has really said why (or if) monads are even still useful. Or catamorphisms.
  Or any of the other dime-store words that the functional community likes to toss around.
• NOW: I think I have to admit that this hasn’t happened—at least,
  there’s been no backlash that I’ve seen. In fact, what’s interesting is that there’s
  been some movement to bring those functional concepts—including monads, which surprised
  me completely—into other languages like C# or Java for discussion and use. That being
  said, though, I don’t see Haskell and Erlang taking center stage as application languages—instead,
  I see them taking supporting-cast kinds of roles building other infrastructure that
  applications in turn make use of, a la CouchDB (written in Erlang). Monads still remain
  a mostly-opaque subject for most developers, however, and it’s still unclear if monads
  are something that people should think about applying in code, or if they are one
  of those “in theory” kinds of concepts. (You know, one of those ideas that change
  your brain forever, but you never actually use directly in code.)
• THEN: ... Visual Studio 2010 will ship on time, and be one of
  the buggiest and/or slowest releases in its history. I hate to make this prediction,
  because I really don't want to be right, but there's just so much happening in the
  Visual Studio refactoring effort that it makes me incredibly nervous. Widespread adoption
  of VS2010 will wait until SP1 at the earliest. In fact....
• NOW: Wow, did I get a few people here in Redmond annoyed with me
  about that one. And, as it turned out, I was pretty off-base about its stability.
  (It shipped pretty close if not exactly on the ship date Microsoft promised, as I
  recall, though I admit I wasn’t paying too much attention to it.)  I’ve been
  using VS 2010 for a lot of .NET work in the last six months, and I’ve yet (knock on
  wood) to have it crash on me. /bow Visual Studio team.
• THEN: ... Visual Studio 2010 SP 1 will ship within three months
  of the final product. Microsoft knows that people wait until SP 1 to think about
  upgrading, so they'll just plan for an eager SP 1 release, and hope that managers
  will be too hung over from the New Year (still) to notice that the necessary shakeout
  time hasn't happened.
• NOW: Uh…. nope. In fact, SP 1 has just reached a beta/CTP state.
  As for managers being too hung over, well…
• THEN: ... Apple will ship a tablet with multi-touch on it, and
  it will flop horribly. Not sure why I think this, but I just don't think the
  multi-touch paradigm that Apple has cooked up for the iPhone will carry over to a
  tablet/laptop device. That won't stop them from shipping it, and it won't stop Apple
  fan-boiz from buying it, but that's about where the interest will end.
• NOW: Oh, WOW did I come so close and yet missed the mark by a mile.
  Of course, the “tablet” that Apple shipped was the iPad, and it did pretty much everything except flop
  horribly. Apple fan-boys bought it… and then about 24 hours later, so did everybody
  else. My mom got one, for crying out loud. And folks, the iPad—along with
  the whole “slate” concept—is pretty clearly here to stay.
• THEN: ... JDK 7 closures will be debated for a few weeks, then
  become a fait accompli as the Java community shrugs its collective shoulders. Frankly,
  I think the Java community has exhausted its interest in debating new language features
  for Java. Recent college grads and open-source groups with an axe to grind will continue
  to try and make an issue out of this, but I think the overall Java community just...
  doesn't... care. They just want to see JDK 7 ship someday.
• NOW: Pretty close—except that closures won’t ship as part of JDK
  7, largely due to the Oracle acquisition in the middle of the year here. And I was
  spot-on vis-à-vis the “they want to see JDK 7 ship someday”; when given the chance
  to wait for a year or so for a Java-with-closures to ship, the community overwhelmingly
  voted to get something sooner rather than later.
• THEN: ... Scala either "pops" in 2010, or begins to
  fall apart. By "pops", I mean reaches a critical mass of developers
  interested in using it, enough to convince somebody to create a company around it,
  a la G2One.
• NOW: … and by “somebody”, it turns out I meant Martin Odersky. Scala
  is pretty clearly a hot topic in the Java space, its buzz being disturbed only by
  Clojure. Scala and/or Clojure, plus Groovy, makes a really compelling JVM-based stack.
• THEN: ... Oracle is going to make a serious "cloud"
  play, probably by offering an Oracle-hosted version of Azure or AppEngine. Oracle
  loves the enterprise space too much, and derives too much money from it, to not at
  least appear to have some kind of offering here. Now that they own Java, they'll marry
  it up against OpenSolaris, the Oracle database, and throw the whole thing into a series
  of server centers all over the continent, and call it "Oracle 12c" (c for
  Cloud, of course) or something.
• NOW: Oracle made a play, but it was to continue to enhance Java,
  not build a cloud space. It surprises me that they haven’t made a more forceful move
  in this space, but I suspect that a huge amount of time and energy went into folding
  Sun into their corporate environment.
• THEN: ... Spring development will slow to a crawl and start to
  take a left turn toward cloud ideas. VMWare bought SpringSource for a reason,
  and I believe it's entirely centered around VMWare's movement into the cloud space—they
  want to be more than "just" a virtualization tool. Spring + Groovy makes
  a compelling development stack, particularly if VMWare does some interesting hooks-n-hacks
  to make Spring a virtualization environment in its own right somehow. But from a practical
  perspective, any community-driven development against Spring is all but basically
  dead. The source may be downloadable later, like the VMWare Player code is, but making
  contributions back? Fuhgeddabowdit.
• NOW: The Spring One show definitely played up Cloud stuff, and springsource.com
  seems to be emphasizing cloud more in a couple of subtle ways. Not sure if I call
  this one a win or not for me, though.
• THEN: ... the explosion of e-book readers brings the Kindle 2009
  edition way down to size. The era of the e-book reader is here, and honestly,
  while I'm glad I have a Kindle, I'm expecting that I'll be dusting it off a shelf
  in a few years. Kinda like I do with my iPods from a few years ago.
• NOW: Honestly, can’t say that I’m using my Kindle a lot, but I am
  reading using the Kindle app on non-Kindle hardware more than I thought I would be.
  That said, I am eyeing the new Kindle hardware generation with an acquisitive eye…
• THEN: ... "social networking" becomes the "Web
  2.0" of 2010. In other words, using the term will basically identify you
  as a tech wannabe and clearly out of touch with the bleeding edge.
• NOW: Um…. yeah.
• THEN: ... Facebook becomes a developer platform requirement. I
  don't pretend to know anything about Facebook—I'm not even on it, which amazes my
  family to no end—but clearly Facebook is one of those mechanisms by which people reach
  each other, and before long, it'll start showing up as a developer requirement for
  companies looking to hire. If you're looking to build out your resume to make yourself
  attractive to companies in 2010, mad Facebook skillz might not be a bad investment.
• NOW: I’m on Facebook, I’ve written some code for it, and given how
  much the startup scene loves the “Like” button, I think developers who knew Facebook
  in 2010 did pretty well for themselves.
• THEN: ... Nintendo releases an open SDK for building games for
  its next-gen DS-based device. With the spectacular success of games on the iPhone,
  Nintendo clearly must see that they're missing a huge opportunity every day developers
  can't write games for the Nintendo DS that are easily downloadable to the device for
  playing. Nintendo is not stupid—if they don't open up the SDK and promote "casual"
  games like those on the iPhone and those that can now be downloaded to the Zune or
  the XBox, they risk being marginalized out of existence.
• NOW: Um… yeah. Maybe this was me just being hopeful.

In general, it looks like I was more right than wrong, which is not a bad record to
have. Of course, a couple of those “wrong”s were “giving up the big play” kind of
wrongs, so while I may have a winning record, I still may have a defense that’s given
up too many points to be taken seriously. *shrug* Oh, well.

What portends for 2011?

• Android’s penetration into the mobile space is going to rise, then plateau around
  the middle of the year. Android phones, collectively, have outpaced iPhone sales.
  That’s a pretty significant statistic—and it means that there’s fewer customers buying
  smartphones in the coming year. More importantly, the first generation of Android
  slates (including the Galaxy Tab, which I own), are less-than-sublime, and not really
  an “iPad Killer” device by any stretch of the imagination. And I think that will slow
  down people buying Android slates and phones, particularly since Google has all but
  promised that Android releases will start slowing down.
• Windows Phone 7 penetration into the mobile space will appear huge, then slow
  down towards the middle of the year. Microsoft is getting some pretty decent
  numbers now, from what I can piece together, and I think that’s largely the “I love
  Microsoft” crowd buying in. But it’s a pretty crowded place right now with Android
  and iPhone, and I’m not sure if the much-easier Office and/or Exchange integration
  is enough to woo consumers (who care about Office) or business types (who care about
  Exchange) away from their Androids and iPhones.
• Android, iOS and/or Windows Phone 7 becomes a developer requirement. Developers,
  if you haven’t taken the time to learn how to program one of these three platforms,
  you are electing to remove yourself from a growing market that desperately wants people
  with these skills. I see the “mobile native app development” space as every bit as
  hot as the “Internet/Web development” space was back in 2000. If you don’t have a
  device, buy one. If you have a device, get the tools—in all three cases they’re free
  downloads—and start writing stupid little apps that nobody cares about, so you can
  have some skills on the platform when somebody cares about it.
• The Windows 7 slates will suck. This isn’t a prediction, this is established
  fact. I played with an “ExoPC” 10” form factor slate running Windows 7 (Dell I think
  was the manufacturer), and it was a horrible experience. Windows 7, like most OSes,
  really expects a keyboard to be present, and a slate doesn’t have one—so the OS was
  hacked to put a “keyboard” button at the top of the screen that would slide out to
  let you touch-type on the slate. I tried to fire up Notepad and type out a haiku,
  and it was an unbelievably awkward process. Android and iOS clearly own the slate
  market for the forseeable future, and if Dell has any brains in its corporate head,
  it will phone up Google tomorrow and start talking about putting Android on that hardware.
• DSLs mostly disappear from the buzz. I still see no strawman (no “pet store”
  equivalent), and none of the traditional builders-of-strawmen (Microsoft, Oracle,
  etc) appear interested in DSLs much anymore, so I think 2010 will mark the last year
  that we spent any time talking about the concept.
• Facebook becomes more of a developer requirement than before. I don’t like
  Mark Zuckerburg. I don’t like Facebook’s privacy policies. I don’t particularly like
  the way Facebook approaches the Facebook Connect experience. But Facebook owns enough
  people to be the fourth-largest nation on the planet, and probably commands an economy
  of roughly that size to boot. If your app is aimed at the Facebook demographic (that
  is, everybody who’s not on Twitter), you have to know how to reach these people, and
  that means developing at least some part of your system to integrate with it.
• Twitter becomes more of a developer requirement, too. Anybody who’s not on
  Facebook is on Twitter. Or dead. So to reach the other half of the online community,
  you have to know how to connect out with Twitter.
• XMPP becomes more of a developer requirement. XMPP hasn’t crossed a lot of
  people’s radar screen before, but Facebook decided to adopt it as their chat system
  communication protocol, and Google’s already been using it, and suddenly there’s a
  whole lotta traffic going over XMPP. More importantly, it offers a two-way communication
  experience that is in some scenarios vastly better than what HTTP offers, yet running
  in a very “Internet-friendly” way just as HTTP does. I suspect that XMPP is going
  to start cropping up in a number of places as a useful alternative and/or complement
  to using HTTP.
• “Gamification” starts making serious inroads into non-gaming systems. Maybe
  it’s just because I’ve been talking more about gaming, game design, and game implementation
  last year, but all of a sudden “gamification”—the process of putting game-like concepts
  into non-game applications—is cresting in a big way. FourSquare, Yelp, Gowalla, suddenly
  all these systems are offering achievement badges and scoring systems for people who
  want to play in their worlds. How long is it before a developer is pulled into a meeting
  and told that “we need to put achievement badges into the call-center support application”?
  Or the online e-commerce portal? It’ll start either this year or next.
• Functional languages will hit a make-or-break point. I know, I said it last
  year. But the buzz keeps growing, and when that happens, it usually means that it’s
  either going to reach a critical mass and explode, or it’s going to implode—and the
  longer the buzz grows, the faster it explodes or implodes, accordingly. My personal
  guess is that the “F/O hybrids”—F#, Scala, etc—will continue to grow until they explode,
  particularly since the suggested v.Next changes to both Java and C# have to be done
  as language changes, whereas futures for F# frequently are either built as libraries
  masquerading as syntax (such as asynchronous workflows, introduced in 2.0) or as back-end
  library hooks that anybody can plug in (such as type providers, introduced at PDC
  a few months ago), neither of which require any language revs—and no concerns about
  backwards compatibility with existing code. This makes the F/O hybrids vastly more
  flexible and stable. In fact, I suspect that within five years or so, we’ll start
  seeing a gradual shift away from pure O-O systems, into systems that use a lot more
  functional concepts—and that will propel the F/O languages into the center of the
  developer mindshare.
• The Microsoft Kinect will lose its shine. I hate to say it, but I just don’t
  see where the excitement is coming from. Remember when the Wii nunchucks were the
  most amazing thing anybody had ever seen? Frankly, after a slew of initial releases
  for the Wii that made use of them in interesting ways, the buzz has dropped off, and
  more importantly, the nunchucks turned out to be just another way to move an arrow
  around on the screen—in other words, we haven’t found particularly novel and interesting/game-changing
  ways to use the things. That’s what I think will happen with the Kinect. Sure, it’s
  really freakin’ cool that you can use your body as the controller—but how precise
  is it, how quickly can it react to my body movements, and most of all, what new user
  interface metaphors are people going to have to come up with in order to avoid the
  “me-too” dancing-game clones that are charging down the pipeline right now?
• There will be no clear victor in the Silverlight-vs-HTML5 war. And make no
  mistake about it, a war is brewing. Microsoft, I think, finds itself in the inenviable
  position of having two very clearly useful technologies, each one’s “sphere of utility”
  (meaning, the range of answers to the “where would I use it?” question) very clearly
  overlapping. It’s sort of like being a football team with both Brett Favre and Tom
  Brady on your roster—both of them are superstars, but you know, deep down,
  that you have to cut one, because you can’t devote the same degree of time and energy
  to both. Microsoft is going to take most of 2011 and probably part of 2012 trying
  to support both, making a mess of it, offering up conflicting rationale and reasoning,
  in the end achieving nothing but confusing developers and harming their relationship
  with the Microsoft developer community in the process. Personally, I think Microsoft
  has no choice but to get behind HTML 5, but I like a lot of the features of Silverlight
  and think that it has a lot of mojo that HTML 5 lacks, and would actually be in favor
  of Microsoft keeping both—so long as they make it very clear to the developer
  community when and where each should be used. In other words, the executives in charge
  of each should be locked into a room and not allowed out until they’ve hammered out
  a business strategy that is then printed and handed out to every developer within
  a 3-continent radius of Redmond. (Chances of this happening: .01%)
• Apple starts feeling the pressure to deliver a developer experience that isn’t
  mired in mid-90’s metaphor. Don’t look now, Apple, but a lot of software developers
  are coming to your platform from Java and .NET, and they’re bringing their expectations
  for what and how a developer IDE should look like, perform, and do, with them. Xcode
  is not a modern IDE, all the Apple fan-boy love for it notwithstanding, and this means
  that a few things will happen:
• Eclipse gets an iOS plugin. Yes, I know, it wouldn’t work (for the most part)
  on a Windows-based Eclipse installation, but if Eclipse can have a native C/C++ developer
  experience, then there’s no reason why a Mac Eclipse install couldn’t have an Objective-C
  plugin, and that opens up the idea of using Eclipse to write iOS and/or native Mac
  apps (which will be critical when the Mac App Store debuts somewhere in 2011 or 2012).
• Rumors will abound about Microsoft bringing Visual Studio to the Mac. Silverlight
  already runs on the Mac; why not bring the native development experience there? I’m
  not saying they’ll actually do it, and certainly not in 2011, but the rumors, they
  will be flyin….
• Other third-party alternatives to Xcode will emerge and/or grow. MonoTouch
  is just one example. There’s opportunity here, just as the fledgling Java IDE market
  looked back in ‘96, and people will come to fill it.
• NoSQL buzz grows. The NoSQL movement, which sort of got started last year,
  will reach significant states of buzz this year. NoSQL databases have a lot to offer,
  particularly in areas that relational databases are weak, such as hierarchical kinds
  of storage requirements, for example. That buzz will reach a fever pitch this year,
  and the relational database moguls (Microsoft, Oracle, IBM) will start to fight back.

I could probably go on making a few more, but I think these are enough to get me into
trouble for the year.

To all of you who’ve been readers of this blog for the past year, I thank you—blog-gathered
statistics tell me that I get, on average, about 7,000 hits a day, which just stuns
me—and it is a New Years’ Resolution that I blog more and give you even more reason
to stick around. Happy New Year, and may your 2011 be just as peaceful, prosperous,
and eventful as you want it to be.

Enterprise consulting, mentoring or instruction. Java, C++, .NET or XML services.
1-day or multi-day workshops available. Contact
me for details.