Without further ado, here’s the list of #ecmband tweets up until 10am US-Pacific on September 4th, 2011 (note: for brevity I’ve removed retweets, meta-comments about the meme, etc.):

Who / When	What	Editorial Comment by Moi
@pmonks 2011-09-04 09:45:35	#ecmband Silly IDOL (with tip o the hat to @CherylMcKinnon for inspiration)
@pmonks 2011-09-04 09:36:38	#ecmband (traffic) INXS
@pmonks 2011-09-04 09:34:57	#ecmband The Niggles
@pmonks 2011-09-04 09:33:19	#ecmband Justin Timetobreak
@pmonks 2011-09-04 09:09:24	#ecmband Madness
@CherylMcKinnon 2011-09-03 17:56:04	#ecmband Building IDOL
@pmonks 2011-09-03 17:52:35	#ecmband New Bids are a Shock
@CherylMcKinnon 2011-09-03 13:44:48	#ECMBand OASIS	Very nice!
@raresva 2011-09-03 09:58:29	#ecmband Weird Al Freskovic cc @pmonks
@raresva 2011-09-03 09:56:02	#ecmband K2
@raresva 2011-09-03 09:38:15	#ecmband Frank Seedata. late to the meme
@pmonks 2011-09-03 08:00:46	#ecmband Arrested Development (schedule)
@pmonks 2011-09-03 07:57:07	#ecmband Megadearth (of good content)
@pmonks 2011-09-03 07:55:29	#ecmband FUD Fighters
@pmonks 2011-09-03 07:53:12	#ecmband Vanilla ICE (In-Context Editing)
@pmonks 2011-09-02 20:15:53	#ecmband Routines of the Stone Age
@pmonks 2011-09-02 20:10:30	#ecmband Midnight Toil
@pmonks 2011-09-02 20:07:52	#ecmband Daft Junk
@pmonks 2011-09-02 20:07:16	#ecmband sCream
@pmonks 2011-09-02 20:04:19	#ecmband Paper Jam
@pmonks 2011-09-02 20:04:09	#ecmband No Order
@pmonks 2011-09-02 20:03:54	#ecmband Linkedin Perk
@pmonks 2011-09-02 20:02:44	#ecmband Cloudplay
@ldallasBMOC 2011-09-02 19:53:38	#ecmband Dolly Partition (disturbing country trend)
@ldallasBMOC 2011-09-02 19:52:30	Conway Twitter #ecmband
@CherylMcKinnon 2011-09-02 19:51:54	#ecmband Johnny Cache
@pmonks 2011-09-02 19:49:29	#ecmband Jackedup Drive	Bit of a stretch from the real band name…
@pmonks 2011-09-02 19:49:09	#ecmband Dolly Partition
@pmonks 2011-09-02 19:48:03	#ecmband Tina CD Burner
@ldallasBMOC 2011-09-02 19:26:55	This is weird even for me – Lyrics to Losing My Revisions http://t.co/GktLhhf #ecmband – blame @pmonks	I think someone needs some therapy!
@sutrosoftware 2011-09-02 19:26:25	The 5-Year Commitments #ecmband
@WillieGonzalez 2011-09-02 19:20:04	@pmonks #ecmband Elvis pRESTley
@c_d_stephenson 2011-09-02 19:18:03	#ecmband Johnny Cache
@c_d_stephenson 2011-09-02 19:17:29	#ecmband Java Jars of Clay
@c_d_stephenson 2011-09-02 19:16:51	#ecmband St(r)ing
@WillieGonzalez 2011-09-02 19:11:48	@pmonks #ecmband Men At Work-flow
@WillieGonzalez 2011-09-02 19:11:05	@pmonks #ecmband WebDAV Lee Roth
@WillieGonzalez 2011-09-02 19:09:55	@pmonks #ecmband Rod SteWAR
@WillieGonzalez 2011-09-02 19:05:32	@pmonks #ecmband ClassPath Benetar
@CherylMcKinnon 2011-09-02 19:04:42	#ecmband The VERS Pipe
@CherylMcKinnon 2011-09-02 18:57:19	Oh dear lord. Home after 4 hours of dinner out and see almost 100 new #ecmband name tweets. Pouring another glass of vino…	Hangover much?
@WillieGonzalez 2011-09-02 18:51:16	@pmonks #ecmband Ozzie Onbase
@WillieGonzalez 2011-09-02 18:49:56	@pmonks #ecmband Depeche Model
@WillieGonzalez 2011-09-02 18:47:51	@pmonks #ecmband Url2
@WillieGonzalez 2011-09-02 18:45:11	@pmonks #ecmband A FileLock of Seagulls	Highly commended!
@WillieGonzalez 2011-09-02 18:43:40	@pmonks #ecmband David Lee Rootnode
@WillieGonzalez 2011-09-02 18:42:16	@pmonks #ecmband Red-Hat Chilli Peppers
@WillieGonzalez 2011-09-02 18:35:06	@pmonks #ecmband N.W.A (Not Without Alfresco)
@dustinv 2011-09-02 18:34:05	@WillieGonzalez @pmonks #ecmband Workflow Rida
@WillieGonzalez 2011-09-02 18:32:07	@pmonks #ecmband L.D.A.P Cool J
@WillieGonzalez 2011-09-02 18:30:10	#ecmband The Pretenders … (you know who they are)
@WillieGonzalez 2011-09-02 18:26:30	@pmonks #ecmband Adam AMP
@WillieGonzalez 2011-09-02 18:25:01	@pmonks #ecmband 10,000(MB) Maniacs
@pmonks 2011-09-02 18:14:39	#ecmband Simple (file) Plans
@sliewehr 2011-09-02 17:44:05	the Monk-eys @pmonks #ecmband
@parapadakis 2011-09-02 17:03:18	Distro’s Midrange Scanners #ecmband
@fmaul 2011-09-02 16:30:57	#ecmband CMIS Non The Richer
@sutrosoftware 2011-09-02 16:24:20	The Search-and-Replacements #ecmband
@sutrosoftware 2011-09-02 16:23:06	@CherylMcKinnon Legal Hold Play #ecmband
@tpeelen 2011-09-02 16:20:50	the Police – Every little thing she scans is magic #ecmband
@fmaul 2011-09-02 16:15:43	#ecmband DJ PDF and the Fresh Prints
@tpeelen 2011-09-02 16:15:33	George Michael & Aretha Franklin – I knew you were waiting #ecmband
@pmonks 2011-09-02 16:11:24	#ecmband Living in a Box (is claustrophobic as all get out!)
@WillieGonzalez 2011-09-02 16:10:22	@pmonks #ecmband Bad Company (EMC Corp)
@tpeelen 2011-09-02 16:07:42	Tears for Years #ecmband	My favourite – perfectly captures the vibe of ECM!!
@tpeelen 2011-09-02 16:06:22	SEO Speedwagon #ecmband
@tpeelen 2011-09-02 16:05:55	The Pixels #ecmband
@tpeelen 2011-09-02 16:00:05	The Crash #ecmband
@pmonks 2011-09-02 15:56:24	#ecmband Buena Vista Social Business 2.0 Club
@pmonks 2011-09-02 15:50:19	#ecmband Deep Trouble
@whitneytidmarsh 2011-09-02 15:49:05	Rockumentum! #ecmband	Trust the marketeers to throw in some fanboi-ism!
@tpeelen 2011-09-02 15:47:22	The Transactional Hip #ecmband
@pmonks 2011-09-02 15:46:42	#ecmband Springclean Day
@piewords 2011-09-02 15:43:47	The Backscan Boys #ecmband
@tpeelen 2011-09-02 15:36:46	Ace of Base64 #ecmband
@parapadakis 2011-09-02 15:36:07	Sonny and Sharepoint #ecmband	Very clever!!
@adeforsan 2011-09-02 15:34:31	#ecmband CEVA lovitch
@tpeelen 2011-09-02 15:33:15	Rendition of the Orphan #ecmband < must be doom metal
@tpeelen 2011-09-02 15:29:33	Orchestral Manoeuvres in the Cloud #ecmband
@piewords 2011-09-02 15:28:38	Monkloaf #ecmband cc @pmonks
@pmonks 2011-09-02 15:26:56	#ecmband Scott and the #Crapronyms cc @sliewehr
@pmonks 2011-09-02 15:24:50	#ecmband Adriaan and the Analysts
@adriaanbloem 2011-09-02 15:24:16	I think Peter and the Chipmonks is enough of an #ecmband by himself @pmonks
@tpeelen 2011-09-02 15:24:06	R.E.M. and their Document LP… too obvious #ecmband
@adeforsan 2011-09-02 15:18:57	#ecmband led zipfiles
@piewords 2011-09-02 15:18:42	The E. Files Band #ecmband
@parapadakis 2011-09-02 15:16:58	Credence Capture Revival #ecmband
@piewords 2011-09-02 15:16:27	Steely Scan #ecmband
@tpeelen 2011-09-02 15:12:56	Limp business #ecmband
@adeforsan 2011-09-02 15:12:39	#ecmband iron mountain #metal
@pmonks 2011-09-02 15:12:14	#ecmband The B-5015.2s
@adeforsan 2011-09-02 15:11:34	#ecmband the shadow (files)
@piewords 2011-09-02 15:11:27	Run-EMC #ecmband	No thanks!
@ldallasBMOC 2011-09-02 15:09:39	Toner-Loc #ecmband
@piewords 2011-09-02 15:09:31	Contellica #ecmband
@pmonks 2011-09-02 15:08:10	#ecmband Jesus Jones… …Documentum is down *again*?!?!
@pmonks 2011-09-02 15:07:40	#ecmband The Jesus and Money Drain
@ldallasBMOC 2011-09-02 15:07:14	Alans Microsoft Project #ecmband
@piewords 2011-09-02 15:07:06	Tommy Duplex #ecmband
@pmonks 2011-09-02 15:06:51	#ecmband Nick Cave and the Bad Feeds
@ldallasBMOC 2011-09-02 15:05:43	Kenny Login #ecmband	In a large and carefully conducted survey (i.e. I asked some friends), this one came out as the crowd favourite. Oh, and we all got written off as “hopelessly geeky”… you win some, you lose some…
@ldallasBMOC 2011-09-02 15:05:25	Dire Straightedge #ecmband (weak I know)
@pmonks 2011-09-02 15:03:42	#ecmband Extreme… …frustration with this archaic, monolithic, proprietary PoS CMS!
@tpeelen 2011-09-02 15:02:42	ZZ Pad – Gimme all your content #ecmband
@ldallasBMOC 2011-09-02 15:02:37	Ink Supply #ecmband
@adeforsan 2011-09-02 14:57:41	#ecmband benny and the gets
@CherylMcKinnon 2011-09-02 14:57:05	#ECMband COLDPlay
@adeforsan 2011-09-02 14:56:40	#ecmband super stamp
@jeffpotts01 2011-09-02 14:56:14	Dexy’s Midnight Publish Job Runners #ecmband (how retro)
@adeforsan 2011-09-02 14:55:56	#ecmband the rolling store (and retrieve ) courtesy @PhilippeLaval
@tpeelen 2011-09-02 14:55:05	OpenText – ‘Managing content loud’ #ecmband
@tpeelen 2011-09-02 14:53:20	The Offline – Punk; always against what is common #ecmband
@pmonks 2011-09-02 14:50:33	#ecmband Simply Read
@ldallasBMOC 2011-09-02 14:50:11	#ECMBand songs “Loosing My Retention” by E.R.M. (think this has been done before)
@pmonks 2011-09-02 14:49:39	#ecmband The Cure (is open source)
@adeforsan 2011-09-02 14:48:02	#ecmband rage against the machine #extendedITmix
@tpeelen 2011-09-02 14:45:23	The New Datamodel Army #ecmband
@CherylMcKinnon 2011-09-02 14:43:02	#ECMBand New Rendition
@tpeelen 2011-09-02 14:35:34	The Hummingbirds #ecmband
@pmonks 2011-09-02 14:34:11	#ecmband Ready, #AIIM, Fire!
@adeforsan 2011-09-02 14:33:03	#ecmband Flows runs and the machine
@pmonks 2011-09-02 14:31:04	#ecmband Laurence and the Hart-ons cc @piewords	I know that this is @piewords secret favourite, but he’d never admit it because he’s suppressing his inner lunatic.
@ldallasBMOC 2011-09-02 14:30:50	Peter and The Requirements @bduhon @cherylmckinnon @pmonks @piewords @jessewilkins @juliecolgan #ecmband
@pmonks 2011-09-02 14:27:51	#ecmband Irina and the Seven Devs cc @irina_guseva
@adeforsan 2011-09-02 14:27:38	#ecmband siouxie and the brand sheets
@pmonks 2011-09-02 14:26:17	#ecmband Lee Dallas and the Textans
@adeforsan 2011-09-02 14:24:23	RT @CherylMcKinnon: #ecmband names… Katrina & the Forrester Waves, New Kids on the Numeric Block, Shania Twain…	(note: not sure why the original is no longer showing up in my twitter search, so I’ve included this RT instead)
@pmonks 2011-09-02 14:24:15	#ecmband The (Style) Police
@pmonks 2011-09-02 14:24:09	#ecmband Spandex Ballet
@pmonks 2011-09-02 14:02:30	@CherylMcKinnon I can see it now “The ECM Mullets present Business Up Front, Party in the Back!” #ecmband cc @piewords @ldallasBMOC	The tweet that kicked it all off.

Footnote: although I used the Twitter API to retrieve these tweets, retrieving all tweets for a given hashtag is still a bit of a crapshoot. As a result I’ve probably missed some of the entries – if you notice any that I have missed, please let me know and I’ll manually add them.

Lane asks for help

(addendum: does anyone else find WordPress.com’s HTML auto-cleansing rules annoyingly draconian??)

So what has me so fired up it’s brought me out of my extended blog hiatus?

Clients Behaving Badly, aka Nasty Vendor Management Games

In a nutshell, these are the games clients play with providers (vendors) of a product or service in order to extract as much value from that provider as possible. Many such games are entirely legitimate (in fact I have increased respect for clients who utilise those!) but there are also many that are inherently exploitative in nature, and it’s those ones that have me fired up at present.

I’m not the first to have commented on these silly games (I wish this post was as entertaining!) and others have commented on the reverse situation – providers playing dirty tricks on clients. The point of this post is that such tricks are not limited to those who sell products or services, let alone those engaged in the Content Management arena.

What I’m going to do here is enumerate some of the more unpleasant games I see being played, primarily during the implementation and production phases (since that’s primarily where I live). If you’re on the provider side this may help you to recognise these games when a client trundles them out and take appropriate action (if any – sometimes it’s appropriate to just play along). If you’re on the client side, I would encourage some honest self-appraisal of whether you’ve used or continue to use any of these tactics when dealing with your providers – keeping in mind that they will likely backfire (or at least be defanged) if the provider wasn’t born yesterday.

In no particular order, here’s my list:

Robo-Questioning

This is where the client asks a provider staff member a question, and if the answer is not to their liking they simply ignore it and ask someone else the same question again (repeating ad nauseam if they get the same answer repeatedly). The game stops when the client gets the answer they were looking for or a reasonable approximation – at that point they hold the entire provider to that particular answer.

In practice it’s rare that this tactic will achieve the result the client is after, since usually there’s a good reason they’re getting an answer they don’t like (particularly if they get the same answer several times). In fact chances are the answer the client liked came from a well-meaning but uninformed member of the provider’s staff and is therefore of dubious accuracy.

Examples:

• Asking a detailed technical question, ignoring the answers from technical staff but accepting the answer from a sales person or marketer.
• Asking a licensing question, ignoring the answers from sales staff but accepting the answer from a technical person.

Selective Deafness

This game is a variation of the previous one. In it, the client asks a question, receives an answer not to their liking, but continues the conversation as if they had received the answer they wanted.

Examples:

• Asking for a discount (so far so good), but then ignoring a “we’re terribly sorry, we cannot discount this” response by saying things like “so that’s agreed then – you’ll send us a quote with the X% discount?”.

Revisionist History

This game involves the client denying prior events or creatively reinterpreting them. In the best case there is documentary evidence from the time the events took place that neatly summarises what actually happened (meeting minutes, for example – learn to document everything you do, kids!), allowing history to speak for itself.

Ultimately though, this game is an extremely toxic one because it completely annihilates any trust that may have existed between client and provider.

Examples:

• Client stating that a particular recommendation was made by the provider when it was not.
• Client asserts that they had never been informed that something they were doing was ill-advised, when in fact they had.
• Client is Winston Churchill, who beautifully summarised this game when he said “History will be kind to me, for I intend to write it”.

Damsel in Distress

I find this one quite depressing, given how trivially it can be avoided (at least if the issues are related to whatever the provider delivers).

The classic manifestation of this game is having a client approach a provider (typically a product vendor of some kind) with the message that their product is “fundamentally broken and you better come over here and fix it RIGHT NOW before we go postal on your a**!”. Typically this message of hope and inspiration is delivered shortly after some important milestone has just been missed.

A common (but panicky) vendor response is to throw some poor professional services peon at the client, promising that all of the problems will magically be fixed. The poor suckerconsultant can see #fail written all over the assignment from light years away, and can see that if only they’d been involved 3/6/9 months earlier disaster would have been averted via an informed design.

To add insult to injury, if the vendor’s sales staff are doing their job, they would have seen the potential for disaster and recommended training and/or professional services early on to help stave it off. If this is the case and the client ignored that recommendation, they will often play a double game of “Damsel in Distress” and “Revisionist History”, presumably figuring that the one-two punch of tactics will bludgeon the provider into submission.

Bullying / Badgering

If the one-two punch isn’t enough, truly obnoxious clients will turn to bullying and badgering to bend the provider to their will (on occasion this game is also played independent of the others). This game has numerous variations, including:

• Leapfrog – complaining up the chain of command when something isn’t going their way (this is a particularly nasty combination of bullying and robo-questioning)
• Threats – ranging from “we’re considering dropping you” to “we’re talking with our lawyers”

Failure to RTFM

This one is so silly I almost can’t believe it makes this list, but, well, it’s also ubiquitous so deserves some air play. This is really just another manifestation of the general trend towards hubris seen amongst techies (a topic which deserves a post all its own, and yes I am as guilty of this as anyone).

Typically this one starts out with a techie thinking something like this: “I don’t need to read some stupid manual to install this here application. How much trouble can I get into by double-clicking install.exe??”

Lots, as it turns out, and you don’t come across very well when you pull a “Damsel in Distress” 6 months later and the provider responds with “that’s described in bold red blinking 48pt Comic Sans on page 2 of the manual”.

Misdirected Accountability

This is typically seen when a client demands that a provider support someone else’s work. This can take quite a wide variety of forms, including:

• Client designs and develops extensions by themselves (without RTFM of course), and those extensions are unstable, perform poorly or any one of a bezillion other problems. They then blame it on the provider and demand that they fix the “broken product”.
• Client engages a third party to implement some extensions to a product, then after that third party has long since ridden off into the sunset demands that the provider fixes bugs in it.
• Provider’s product uses some third party product (a relational database, for example) but client doesn’t have the skills to maintain or support that third party product so over time the entire system becomes slow and/or unstable. They then blame the provider’s product, since that’s where the symptoms are most visible.

Blamestorming / Finger Pointing

This game often follows on from Damsel in Distress, particularly if jobs are at stake. Rather than focusing on determining where problems lie and addressing them (irrespective of fault), the client team reverts to an unproductive game of finger pointing.

Foil Bait

This is a pre-sale game where the client is using the provider as leverage with their incumbent provider, or another provider that they are actually interested in. This is a commonly used tactic on open source software vendors, since there are some clients who see open source as little more than a great way to scare traditionally licensed vendors into discounting their hefty up front license fees.

An obvious warning sign is a prospect that is very interested in pricing, but isn’t particularly interested in product functionality or service offerings.

In Conclusion

And there you have it – a veritable Smörgåsbord of unpleasant client behaviours that anyone who’s worked for a provider of some kind (be it product or services) is likely to have seen at one time or another.

I have no illusions that this post will help reduce the prevalence of these antics, but at least by shining a spotlight on them I can encourage providers to be vigilant, and enter new client relationships trusting that they will be conducted respectfully and to mutual benefit, while also verifying that silly games aren’t on the cards.

For this kind of exercise I’m quite partial to ye olde comparison matrix – a table with the alternatives listed horizontally (in our case that’s the different classes of NoSQL technology) and with comparison criteria listed vertically (in our case our CPS requirements). You then play a “fill in the blanks” game for all of the cells in the table.

While simple and effective, comparison matrices have a tendency to be rather information-dense – for that reason I’ve elected to use boolean yes / no values in each cell, rather than more granular scoring systems (such as numerical scales). If we were doing a more thorough comparison (say, if we were actually implementing a CPS on top of a NoSQL technology) I would want to use a variety of more granular scoring systems.

Let’s dive in:

		Key / Value	BigTable-like	Document	Graph	Relational (for comparison)
1	Richly structured content types				1	1
2	Unstructured binary objects				2	3
3	Relationships / references / associations
4	Schema evolution4		5
5	Branch / merge
6	Snapshot-based versioning
7	ACID transactions6			7
8	Scalability to large content sets					8
9	Geographic distribution			9
REQUIREMENTS MET		4	4	5	5	4

One of the nice things about comparison matrices is that they immediately highlight the differentiating criteria for any given comparison, allowing one to focus the discussion on those areas where compromises will be necessary.

Looking at the matrix above, the eye is immediately drawn to rows 1, 2 and 3, which is where the variability between the different classes of NoSQL is found. In fact what this immediately tells us is that there’s no “perfect” class of NoSQL for our CPS requirements – none of them satisfy all three of the following requirements:

• Richly structured content types
• Unstructured binary objects
• Relationships / references / associations

What’s worse are rows 5 and 6, and (to a lesser extent) row 9. These rows indicate that there are entire requirements that no extant NoSQL technology satisfies.

In looking at these 3 requirements in isolation, there is an obvious class of systems that do satisfy them – Source Code Management (SCM) systems, especially Distributed SCMs (Mercurial, Bazaar, git and the like). It is important to stress that DSCMs don’t meet many of the other CPS requirements however (for one thing the “data model” they expose is a filesystem, which is completely unsuited for CPS content modeling), so they’re by no means an appropriate CPS repository in and of themselves.

The conclusion I’ve drawn is that the ideal CPS repository would be a three-way love child between 2 classes of NoSQL solution (document and graph databases) and DSCM. Specifically:

• Document database style data model (satisfies requirements #1, #2, #4 and #7) plus Graph database style relationships (satisfies requirement #3)
• SCM style versioning and branch/merge (satisfies requirements #5 and #6)
• DSCM or CouchDB style multi-master replication and conflict detection (satisfies requirement #9)

I think of this hybrid as a “Document-Relational¹⁰ Version Control System” (DRVCS for the acronym junkies).

All three kinds of system meet requirement #8 when used in isolation, and a cursory analysis doesn’t reveal any obvious reasons why the DRVCS couldn’t retain this characteristic (although the devil is often in the details when it comes to questions of scale).

The bigger questions here are whether anyone is considering implementing such a repository, and if not whether it’s possible to emulate the missing requirements on top of any of the extant NoSQL technologies.

To the first point, I’m not aware of any efforts aimed at implementing a DRVCS, although I’m by no means familiar with all of the repository development going on out there. I’m also sure I’ll receive comments that such-and-such a technology already meets all of these requirements. I’m skeptical that such a beast actually exists, but would love to be proven wrong – what would convince me is the addition of the technology to the comparison matrix above, with a brief description in each of the new column’s cells describing how the technology satisfies each requirement.

I’ve also spent a bit of time thinking about whether it would be possible to build out the missing features on top of an extant NoSQL technology, and at this stage my gut tells me that the branch / merge and snapshot based versioning requirements would be difficult (and probably impractical) to build on top of any of these technologies. These features are technically complex enough that they deserve first class support in the repository, rather than being implemented as an “emulation” layer on top of something else.

Next Up

Next up I’ll be reviewing the repository-level requirements for Presentation Management CMSes, and we’ll repeat this comparison process to see how NoSQL technologies stack up against that use case. Fingers crossed for a more positive outcome!

And you thought the NoSQL moniker was simply a clever marketing ploy to incite rage amongst relational aficionados!

While Wikipedia lists no less than 7 major types of NoSQL solution, the “Big 4″ that are discussed most frequently are:

1. Key / Value
2. BigTable-like
3. Document
4. Graph

Let’s look at each of them in turn.

Key / Value

These solutions are typically little more than sophisticated distributed hash tables, often adding direct support for some combination of persistence (durability of data across restarts), replication (physical duplication of data, typically across multiple servers) and sharding (partitioning of data into discrete subsets, each of which is stored on separate sets of servers). They often restrict what data can be used for keys, while allowing values to be any kind of data that can be serialised. Typically querying can only be done by key.

Some examples:

• Memcached
• Project Voldemort
• Amazon Dynamo

BigTable-like

These solutions are based on Google’s BigTable system (used internally by Google, as well as being the primary data storage facility available to Google App Engine developers). They can be thought of as being one step above a Key / Value store in that the values are not simply unstructured binary blobs that are opaque to the store, but are instead structured data elements that can be used for additional non-key based queries.

In some respects these solutions are quite similar to a relational database, minus explicit foreign keys, and with support for different “rows” in the same “table” having different “columns” (this is somewhat of an over-simplification, but from a data/content modeling perspective is reasonably accurate).

Some examples:

• Apache Cassandra
• Apache HBase

Document

Document databases store “flat” collections of structured documents – in this case “document” does not (as the name might suggest) mean binary documents (Word, PDF etc.), but rather structured data objects with potentially rich internal structures.

The current generation of document databases have, for the most part, standardised on JSON as the underlying data format for documents, however I consider XML databases to fall under this umbrella as well (albeit many of those have additional facilities for slicing and dicing XML in various weird and unnatural ways that are illegal in some states).

Interestingly, query facilities vary widely between the extant document databases, with some offering query facilities on par with relational databases, while others don’t provide anything resembling a traditional query capability^†.

Some examples:

• MongoDB
• Apache CouchDB
• eXist
• MarkLogic

Graph

Graph databases are unquestionably the oldest NoSQL solution, with at least one example predating the relational model by several years!

In these databases, data is stored as a series of discrete objects (“vertexes”) connected by zero or more relationships (“edges”) to one another. Typically the objects are simple hash table data structures and cannot have rich internal data structures (in contrast to a document in a Document database).

Some examples:

• Neo4J
• AllegroGraph
• InfoGrid

Summary

Borrowing a nice diagram from the Neo4J folks, one way of comparing the different classes of NoSQL solution is as follows:

^{Note: when looking at this graph I mentally replace the “Complexity” label with “Sophistication of data modeling” – the diagram is equally accurate with that substitution and to my mind that’s a more interesting picture (not to mention more relevant to the discussion of CMS and NoSQL).}

In the next post we’ll instead look at how these classes of NoSQL solution compare to the CPS requirements we previously identified.

Addendum

There are any number of good NoSQL primers available on the interwebitubes, and I’d encourage you to read them if you’re new to the topic. I particularly like:

1. Slides 11 through 17 of “A NOSQL Overview And The Benefits Of Graph Databases (nosql east 2009)” by Neo4J’s Emil Eifrem.
2. NoSQL – the Shift to a Non-Relational World
3. NoSQL – Death to Relational Databases(?)
4. Ricky Ho’s NOSQL Patterns (if you’re after a little more “meat”)

^† Before I get flamed to a burnt crisp by the CouchDB fanbois, yes I’m quite familiar with map/reduce “materialised” views – I simply don’t consider that to be a “real” query mechanism. This feature also runs afoul of my “avoid crystal ball gazing at all costs” principle, but that’s a topic for another day.

Typically these requirements will focus on the “repository” underlying the CMS – how content is represented, how it is structured, how it is stored and retrieved, how the repository is scaled to large traffic volumes and so on. This is not to diminish the importance of other requirements (such as the editorial UI/UX), however NoSQL has a lot less direct relevance to those facets of a CMS.

Let’s kick off the series with my favourite CMS use case – the Content Production System (CPS).

Requirements for a CPS

A CPS has a number of requirements that are relevant to NoSQL solutions. These include:

1. Richly structured content types
2. Unstructured binary objects
3. Relationships / references / associations
4. The ability to evolve content models over time (what I call “schema evolution”)
5. Branch / merge (in the Source Code Management (SCM) sense of the term)
6. Snapshot based versioning
7. ACID transactions
8. Scalability to large content sets
9. Geographic distribution

Let’s discuss each of these in more detail:

Richly Structured Content Types

In my experiences, types in a WCM content model are generally more complex than those in other content management use cases (e.g.. Document Management), with complex nested data structures within types being the norm rather than the exception.

While the specifics vary widely depending on the precise information architecture of the web site, some typical examples might be^†:

• News Article:
  • a number of singleton fields such as “title”, “summary”, “author”, “date”, “body” etc.
  • an unbounded set of related image files, each of which has a “thumbnail” and a “high fidelity” rendition. These images may have further fields associated with them (provenance information, for example).
• Product:
  • a number of singleton fields such as “SKU”, “title”, “description”, etc.
  • a variety of images such as “thumbnail”, “high fidelity”, “left view”, “right view”, etc.
  • nested data structures such as a regional price list – a set of (country code, currency, price) tuples
• Recipe:
  • a set of ingredients, each of which has:
    • singleton fields such as “name”, “quantity”, “optional / required flag”, “substitutes” etc.
    • a nested data structure containing nutritional information
  • an ordered set of preparation instructions

^† All of these are based on actual WCM content models I have seen used in live web sites.

Unstructured Binary Objects

A no-brainer really – any CMS (WCM or otherwise) that is unable to efficiently store binary objects (regardless of MIME type) isn’t worthy of the moniker. Enough said.

Relationships aka References aka Associations

WCM content models are inherently interlinked, after all that’s what the “hyper” in “hypertext” refers to! Continuing our examples above: a Product may contain references to complementary Products and other content types such as Technical Specifications, White Papers etc.; a News Article might refer to related News Articles, and so on.

In fact often the most highly interlinked part of a WCM content model are the content types representing the navigational model of the site. Regardless of whether the site uses a traditional single-root hierarchy, a multi-hierarchy (“faceted”) navigation scheme, a tag cloud or some wacky newfangled model dreamt up by a genius information architect, the content type(s) representing the navigational data structures are always highly interlinked with the non-navigational content types (the Products, News Articles, Recipes, etc.) and are often interlinked with themselves. This latter case is particularly true of hierarchically based navigational schemes, which continue to be the dominant navigational paradigm used in content-rich web sites.

While it is possible to “manage” links via the humble hyperlink (and in fact this is the de-facto approach in several CPSes), this is less than ideal for various reasons:

• it’s difficult to inform an author that they’re about to break links on the site by moving or deleting a content item that is the target of a reference
• it’s difficult to determine what needs to be deployed in order to ensure that all dependencies are met (i.e. so links won’t be broken, post-deployment)
• the graph of links provides useful information to authors about the dependencies within their content set, possible navigation paths through the site etc.
• coupled with usage analytics data, visualisations of the link graph can be a powerful tool for authors in revising, distilling and generally maintaining the relevance of the content they’re delivering

Schema Evolution

A general guiding principle that I have followed throughout my technical career has been to avoid (as far as possible) anything that requires what I refer to as “crystal ball gazing” – making decisions now that require prediction of the future and that may be difficult to correct when that prediction turns out to be incorrect (as inevitably happens).

Content models are a classic example of this – in the decade or so that I’ve been working in content management professionally, I don’t recall a single instance where the content model was defined perfectly first time, up front, prior to use.

Unfortunately some of today’s CPSes make it extremely difficult to change the definition of a content type once that type has instances in existence – requiring (for example) a full dump / reload of the entire content set for even the most trivial of changes to the model.

This is the crux of the “schema evolution” requirement – any CMS worth a damn must provide the ability for the content model to evolve over time, regardless of whether content that uses that model exists or not.

Branch / Merge

This is the ability for an author (or set of authors) to spin off from the main “branch” of editorial activity, work independently for some period of time and then merge their changes back into the main “branch”.

This is an optional (though common) requirement – some CPSes don’t provide this capability and some editorial teams don’t require it either.

That said, any web site that has a lifecycle that involves both frequent incremental revisions and infrequent major revisions that are prepared in parallel will benefit from this kind of functionality. Anyone who’s ever managed multiple concurrent software releases will grasp the issue (and its solution) immediately.

Snapshot Based Versioning

By “snapshot based versioning” I mean a versioning system that captures the full state of the content set at a given point in time, and can resurrect that state at any point in the future, regardless of what operations are executed by authors in the meantime (including deletes, renames and moves of assets).

Anyone who suffered through RCS / CVS in the good old days and is now using a sane SCM (Subversion or Mercurial, for example) will know exactly what I’m referring to here!

Surprisingly, some CPSes continue to use RCS style per-asset versioning, which means they are unable to resurrect deleted assets – a serious problem if your web site happens to fall under one of the regulations (e.g. HIPAA, SEC, FTC, etc.) that require that the complete state of a site be “resurrectable” for quite significant periods of time (often 7 years).

ACID Transactions

Basically this boils down to the guarantee that modifications to the content set can be durably persisted to the CPS, either succeed or fail in their entirety and can be read back out in the case of success. To many this will seem a no-brainer, but when we move on to our review of NoSQL solutions we’ll find that some of them don’t necessarily provide this guarantee.

Note: while advantageous in some situations, I consider externally defined transactional boundaries (i.e. the ability to “batch up” numerous otherwise unrelated content modifications into an arbitrary ACID transaction) to be a “nice to have” requirement, rather than a hard requirement. Again we’ll see the impact of this when we review NoSQL technologies.

Scalability to Large Data Sets

Interestingly, scalability in the presence of large amounts of traffic is the area where NoSQL technologies garner the most attention, yet it is one of the least important requirements for a CPS. This is because even large (several hundred person) editorial teams are unable to generate the kind of traffic load that even a moderately successful web site can receive.

However what does matter is that the CPS can scale in the presence of large amounts of data – typical content-heavy web sites these days contain tens to hundreds of thousands of discrete content items, many of which will contain several media assets (images, video, fire applets, etc.) that themselves may be heavyweight (MB to GB in size).

Geographic Distribution

Basically this requirement is for those organisations that have geographically distributed editorial teams who wish to ensure good performance of the editorial tool, no matter where the editors are physically located.

Although in essence a “nice to have” requirement, I threw it in here because I’m hearing it increasingly often and some NoSQL solutions cater to it quite nicely.

Next Up…

Next up I’ll give a quick overview of some (but not all!) of the more relevant NoSQL technologies currently on the market, and we’ll compare them against the requirements we’ve defined here to see to what degree they are relevant to the CPS use case.

As discussed previously what is meant when we refer to a “CMS” varies quite significantly depending on the use case, and my initial focus will be on the impact of NoSQL on CMS’s that target the Web Content Management (WCM) use case, followed with a post on the impact of NoSQL on the Document Management (DM) use case.

Even within the seemingly narrow confines of WCM, we’re discussing (at least!) two different problem domains (Content Production Systems and Presentation Management Systems) that have markedly different requirements (and are arguably unrelated), and I’ll discuss the impact of NoSQL on each of these areas in turn.

Let’s begin!

While most of my observations have been made on Twitter, I thought I’d capture them here for perpetuity. Without further ado, I present to you “Signs You’re at a Geek Conference”:

Sign #42 you’re at a geek conference: the line for the men’s is out the door & the women’s is vacant.

Sign #117 you’re at a geek conf: presenter with European accent says “shart” & no one laughs – they know he’s talking scalability.

Sign #13 you’re at a geek conference: 87% of attendees are using Macs, and 47% of those have “Powered by Ubuntu” stickers on them.

Sign #1 you’re at a geek conference: you make lists of geeky things you see there and share with everyone you know (from my good friend BRob / br524 on Twitter)

Sign #73 you’re at a geek conference: there are lots of attractive young ladies… …but what’s with the “staff” t shirts?

Sign #37 you’re at a geek conference: rickets is the most commonly discussed health issue.

Sign #64 you’re at a geek conference: you overhear “their PL/1 code wasn’t up to COBOL standards” (tip o’ the hat to LuisSala).

Sign #51 you’re at a geek conference: lots of tender loving talk about babies… …but 99% referring to stealth mode startups.

Sign #82 you’re at a geek conf: pool tables are empty but 5 of the last 7 foosball world champions are duking it out in the rec. area.

Sign #90 you’re at a geek conference: you compliment someone on their period costume, and they give you a death stare.

In this post I’d like to capture the mental picture I have of how Content Management fits together, neatly putting all of the pieces of the CM puzzle (DM, WCM, RM, AA^†, etc.) in their rightful place. As a bonus we will also learn how and why various products (including our good friend WordPress) fit into the Content Management menagerie.

^{† I consider AA to be part of CM, as beer consumption appears to be an increasingly important part of the Content Professional’s technical proficiency.}

A Hierarchy of CM Problem Domains

In my previous post I introduced the “Reversi Rule” and noted that for CM we came up with the rather broad definition of “the management of content”. To me this generality is a large part of the appeal of the term (particularly when compared to ECM, which is just downright confusing) – it generously includes the diverse array of human endeavours that could conceivably be classified as “Content Management”, it doesn’t say anything about what those specific problem domains look like (beyond requiring that they involve the “management of content”, for some reasonable definition of “management” and “content”) and it doesn’t exclude any of the broad range of actors who face these problems (including, but not limited to, enterprises).

So what specific value, then, does such a broad definition for Content Management provide us?

Perhaps I’m betraying my technologist background, but to me Content Management clearly forms the root of a hierarchy of increasingly specialised problem domains – in graphical format, this hierarchy might start to look something like this:

^{Note: this diagram does not attempt to capture all possible CM problem domains, although doing so would be an illuminating exercise.}

This diagram clearly illustrates a couple of important points:

1. A vast array of activities can be referred to as “Content Management”.
2. Many of these use cases have unique and highly specialised requirements, particularly as we get closer to the tips of the tree.
3. Some of the management activities we think of as being common across the hierarchy actually have quite different semantics depending on the specific problem domain (versioning requirements are very different between Docroot Revision Control and Records Management, for example).
4. File / folder-centric definitions of content are only part of the content management picture.

A graphical treatment also helps to highlight part of the reason why we’re all having so much trouble agreeing on what “Content Management” really is – we all tend to operate down at different tips of the tree, yet throw around our specific problem domain as The One True Form of Content Management^TM!

I think this gets to the root of Pie’s earlier loss of composure, yet he is arguably guilty of the same sin, albeit while standing on a different soap box.

What About the Technology?

Typically software products are a trailing indicator of business problems, so it’s no surprise to find that there are systems for almost all of the use cases identified on the diagram. In fact adding the word “System” or “Software” to most of the labels on the diagram will result in an extant product classification. There are a few exceptions (“Docroot Revision Control System” and “Structured Content Production System”, for example), however there are products on the market today that are admirably described by these two terms.

The Bonus Round

Going back to our (by now somewhat fatigued) example of WordPress, it clearly falls into the node labeled “Blogs”, and by adding “System” to the label we get “Blog System”. Sounds fair – I doubt anyone would dispute that WordPress is indeed a Blog System.

Now by looking at the diagram we can see that a Blog System is a specialised form of Presentation Management System, which itself is a specialised form of Web Content Management System, which is finally a specialised form of Content Management System. I can hear some incredulous voices: “are you asserting that WordPress is all of these things?”. Absolutely!

Let’s pick some more examples, to see if we can break this model:

• Alfresco RM – clearly a Records Management System therefore also a Document Management System, therefore also a Content Management System.
• Virage MediaBin – this is an easy one: the web site explicitly touts it as Digital Asset Management, so only one step and we arrive at Content Management System. NEXT!
• Ektron eWebEditPro (here’s a potentially contentious one!) – again the web site tells us it’s HTML Editing Software, therefore a Web Content Management System and a Content Management System.

Interesting eh? All these vastly different systems (we’ve just picked 4 that are completely different from one another), yet all of them provide specialised facilities for the management of content central to various different problem domains. They’re all Content Management Systems!

To paraphrase Drew Carey, next time you’re at a social event without companionship or sustenance, I’d encourage you to play “pin the CMS tail on the product donkey” (allowing yourself the ability to extend the hierarchy above with categories that I left out) – I think you’ll mostly find it a trivial exercise.

In Conclusion

At this point you might still be asking yourself what all this means and whether there is any real value in such a broad definition for Content Management.

My answer to that would be that an inclusive definition such as this one comes closest to the true meanings of the words “Content” and “Management”, without requiring us to open the can of worms that would be involved in trying to define these two words in detail (which is impossible anyway, since their precise definitions depend on the specific problem domain).

More importantly, by not requiring us to come to some global agreement about what “content” and “management” mean, this definition can help us move beyond the historical divides within the profession (notably the divide between the Web Content Management and Document Management camps), by giving us common terminology that is compatible with how these terms are used today by all camps, while also being sufficiently well defined that everyone knows what’s implied (and just as importantly, not implied) when someone make an assertion such as “Microsoft Word is a Content Management System”.

To me the discussion about what “ECM” means is fundamentally based on the definition of “Content Management” in general, and more specifically, the definitions of all of those things that are thought of as being part of humanity’s “Content Management” activities (including, but by no means limited to: Web Content Management; Document Management; Records Management; Image Management; Digital Asset Management; Print Management; etc.).

So how might we go about defining all these things?

The Reversi Rule

Now some would argue (persuasively, in many cases!) that I’m just simpleminded, but I’ve always used a nice simple rule for figuring out what a complimicated name such as “Document Management” means – I like to call it the “Reversi Rule” (Reversi is such a nice simple game!):

Approximately reverse the words in the name and then fill in the blanks to construct a grammatically correct sentence.

So using this rule:

• “Document Management” is “The management of documents”.
• “Web Content Management” is “The management of web content”.

And most tellingly:

• “Content Management” is the (rather broad) “management of content”.

A Short Digression…

Now this may seem like little more than childish word play, but it actually enables us to unambiguously answer some rather interesting questions, such as the ever-popular-on-twitter “Is WordPress a CMS?”.

The reasoning goes something like this:

Q. What is a CMS?
A. A system that manages content.  (Reversi Rule)

Q. Is WordPress a system?
A. Yes it is.  (very little ambiguity here!)

Q. Does WordPress provide management features?
A. Yes it does, including the most important features for an author of web content: editing, version control and publication.  (one might argue that “management” is more than this, but these three are amongst the most important activities an author of web content performs on their content, regardless of the system they’re using)

Q. Is what WordPress manages content?
A. Yes it is – content in the form of blog posts and pages.  (again, very little ambiguity here, although no one would dispute that this is a rather limited view of what web content is)

So when measured against our definition of “CMS”, WordPress passes with flying colours – it is unequivocally a system that manages (edits, versions, publishes) content (blog posts, pages).

So what has this go to do with “ECM”?

Well by applying the Reversi Rule to “ECM”, we get:

• “Enterprise Content Management” is “The management of enterprise content.”

But what is “enterprise content”? Is it web content? Documents? Paper (physical or scanned)? Records? Digital media assets? As I’ve argued before, it could be none, any, or all of the above – it depends on the enterprise in question.

That’s not very promising, so let’s try again:

• “Enterprise Content Management” is “The management of content in an enterprise.”

Well we still have the problem of deciding what that content is, and we’re now excluding those organisations that aren’t structured as enterprises in the first place! What about the (these days literally!) poor governments of the world that are just as desirous of content management as enterprises are??

Conclusion

The conclusion I’ve drawn is that “ECM” is a chimera of a term that cobbles together two completely unrelated concepts: “content management” (the management of content) and “enterprise” (a company that has been organised for commercial purposes).

For this reason I think “ECM” is a term that provides no value over and above other terms (specifically “Content Management”), and I suspect that’s part of the reason why Pie and others have struggled so long to try to find a workable definition that does more than just confuse the heck out of any unfortunate souls who come into contact with it.

I also suspect that deep down, Pie has at least some subconscious inkling that “CM” is a superior term to “ECM”, as evidenced by a recent brain snap. As demonstrated in the WordPress digression above, the usage of the term “CMS” that Pie finds so objectionable is indeed justified, if perhaps not the full picture. This is something I intend to explore further in a subsequent post.

For quite a while now, Pie has been on a virtuous crusade to clearly define what is meant by the term “Enterprise Content Management” (ECM). In a late December post entitled “Turning the ECM Definition Around”, Pie neatly justified his search as follows:

Back in October, there was some debate on updating the definition of ECM. Since then, there has been discussions out there about whether the term ECM should even be used anymore. My basic opinion is, and has been, that we need to fix/update the definition, not the term. Changing the term would require a lot of work to educate people for very little gain.

Earlier this week Pie continued his hunt for the (thus far elusive) “perfect definition” of ECM with his post ECM or Document Management?, and a number of the points made in the post rang particularly hollow to my ears.

To paraphrase, the post asserts that ECM, at its core, is little more than Document Management (specifically, management of the files produced by Office productivity applications), and that none of the other extant Content Management use cases (Records Management, Digital Asset Management, Web Content Management, Collaboration etc.) are necessary for a system to be defined as an ECM CMS (although they may be provided as optional extensions to the core DM feature set).

Micro Slice
At a micro level, I think this view ignores recent† thinking about what constitutes a “document” – specifically the accelerating move away from the persistence of content as monolithic “binary content blobs” (PDF being the canonical example) stored in simple folder hierarchies, to open, semi-structured formats (DocBook, DITA, ODF, the Office 2007 XML formats, etc.) stored in repositories with richer navigational constructs (search, tag clouds, categorisation, etc.).

While these semi-structured formats can usually be “flattened” into files (in most cases as XML, although there are other equally suitable structured file formats) and stored in simple folder hierarchies, this is very much a lowest common denominator storage format, and far more interesting (and valuable!) possibilities open up if content is stored in a more modern, non-file/folder based repository (see my earlier post for a brief discussion of the storage mechanism such a hypothetical CMS might use).

Current Document Management products, on the other hand, are still firmly rooted in the “big blobs of data stored in folder hierarchies” view of content storage, and that suggests a couple of things:

1. There is demand for, and value in, systems that are rooted in the “dumb file/folder” world view. Whether these deserve to retain the title of “Document Management System” remains to be seen, but my $0.02 is that the definition of Document Management will evolve to keep pace with developments in the field, quite possibly faster than the current batch of “DM CMSes” can innovate to keep up.
2. Balancing this, “Document Management” as a term has accumulated two decades of baggage, and (like the term ECM itself), that inertia will be difficult to shake off.
3. ECM as practiced today is far more than “dumb file/folder” management – which segues nicely to a second helping of pie

Macro Slice
At a macro level I simply need to point to the types of content that many enterprises are managing and the use cases they have for that content.

Take Amazon for example, arguably the poster child of a wildly successful content-centric Enterprise (disclaimer: I have never worked for or on behalf of Amazon, so anything I state here is educated guesswork on my part, based solely on publicly available information). I would be very surprised if much of their content was in a file format of any flavour (binary content blob or semi-structured), and it’s highly unlikely that they manage it in “dumb” folder hierarchies either (whether on a “real” filesystem or in a file/folder-centric CMS).

On top of this, Amazon’s use case for their content is classic WCM – much of their content ends up on what is arguably the largest brochureware site on the internet, with the classic brochureware goal of enticing customers to buy more of Amazon’s product (which, in some cases, is itself digital content, but that’s a topic for another post).

Amazon isn’t the only example of an Enterprise managing content in this way or for this purpose, yet if (as Pie argues) the term ECM is synonymous with the narrow definition of Document Management, Amazon isn’t doing Enterprise Content Management! So is Amazon doing it wrong, or is our working definition of ECM still insufficient to describe how today’s Enterprises manage their content?

† “recent” meaning “within the last decade or so”

1. Content Management RFPs will continue to be liberally strewn hither and yon like confetti at a WASP wedding, with zero regard for their efficacy or otherwise.
    
2. There will be at least one spectacular† flameout when an otherwise solid WCMS is shoehorned into a completely inappropriate use case, and then explodes in a shower of shiny sparks. This will be a direct result of WCM continuing to be misidentified as a single commoditised use case – an issue that has been beaten to death in the past, but still has no remedy in sight.
    
3. Map / reduce will be touted as the One True Answer to Everything, while RDBMS stalwarts struggle in vain to calm the hysteria and remind everyone that it’s “merely” a handy way to crunch large data sets.
    
4. Suffering indigestion, OpenText will divest themselves of at least one of their product portfolio.  My money is on the former Tower products acquired via the Vignette purchase – they were a going concern before Vignette acquired them, and have remained relatively independent since then.
    
5. SMB / CIFS will remain the most popular remote filesystem protocol in existence, despite being the worst (except for all the others).  (with apologies to Winston Churchill)
    
6. JCR will continue to be ignored by all of the “top shelf” CMS vendors – rapid adoption of CMIS on the server side will amplify the collective yawn that JCR evokes amongst CMS vendors.
    
7. Momentum will continue to build on the CMIS client side – I humbly disagree with Pie’s #3 prediction for 2010 on this point, as there’s already been significant CMIS client development, and that’s before the spec has even been ratified.  (I realise this is more of a “top” prediction, than a “bottom” prediction, but even a curmudgeon has his sunny moments!)
    
8. The Cloud will be the teenage sex of 2010 – everyone says they’re doing it, but only a small subset really understands what’s involved and an even smaller minority of those are actually doing it “for real”.  (note: The Cloud narrowly beat out Enterprise 2.0 for this title – I expect to see a great return match next year!).
    
9. (speculation) Ektron will be acquired by Microsoft in order to jump start Sharepoint’s WCM capabilities.
    
10. (super speculation!) Duke Nukem Forever will be released and will cure all those evil Wiiborgs of their sordid, physically demanding “gaming”.

And there you have it – my bottom 10 list for 2010.  I hope this is enough to regain Justin’s respect, although I may have gone a little overboard with one or two items on this list. 

† “Spectacular” meaning it will become a cautionary tale in CMS circles.

For my first act, I plan to (finally) fulfill a promise I made to Justin Cormack, outlining my bottom 10 predictions for 2010.  What else would you expect from a curmudgeon?