Through this open world I’m about to ramble,
Through ice and snows, sleet and rain,
I’m about to ride that mornin’ railroad,
P’raps I’ll die on that train.
- MAN OF CONSTANT SORROW

During the panel discussion at the recent British Computer Society Open Source event, there was discussion (and confusion) about Open Source versus Open Standards. I was asked “So, can you give us some examples of Open Standards”. I rattled off a few, but I thought I’d add a few more here. There is a lot more to be said on the topic, but a good place to start is to list the standards that I think are important.

If I get the time, I plan to turn this into a nice diagram that is much more easily digestible. If there are important standards that I’ve forgotten about that anyone interested in web sites should know about, please let me know in the comments. I’d avoided worrying about file formats (e.g. PNG, MPEG, PDF). And REST isn’t a standard – it is an architectural style that was developed in parallel with the HTTP/1.1 protocol. I’m sure there are many many important ones I’ve left out though.

This is a long and boring post with a record-breaking number of acronyms. So maybe you should stop reading now.

The Internet Plumbing

These standards are the plumbing of the Internet. Like the sewers under a big city, they are impossible to change and will be there forever. They’re infrastructure. Some people are saying Twitter has already become infrastructure, but I’m not convinced about that yet. These standards are split into layers – the link layer is about physical connection to a network and include standards such as Ethernet. The Internet layer routes packets of information across one or more network using the Internet protocol (IP). The Transport Layer is responsible for the reliable delivery of messages, and uses standards such as TCP or UDP. Finally, the Application Layer provides higher level application specific protocols such as DNS, HTTP (and WebDAV) for web servers, FTP, SMTP for mail servers, NTP for time servers, LDAP for user directories and so on. But I’m not here to talk about any of these. I want to talk about the standards that sit on top of these, specifically for web pages.

Making Web Pages

First 10 Years of the W3C - Click for large version

Let’s start with the standards we know and love that make up web pages. Of course we have HTML 4, XHTML and the eagerly awaited HTML 5. We make our HTML pretty using Cascading Style Sheets (CSS) and we interact with the page using the Document Object Model (DOM), which has a large number of associated standards. Note AJAX is not a standard, despite what you might hear. The XMLHttpRequest DOM API (which can be used to implement AJAX) is currently a last call working draft and may be a W3C standard soon. Another client side standard, Scalable Vector Graphics (SVG) never really took off and probably never will.

So we have standards to make interactive web pages that may or may not be semantically rich. But the world would be a better place if these pages can be accessed by as many people as possible. So we have accessibility standards as part of the Web Accessibility Initiative (WAI). These include Web Content Accessibility Guidelines (WCAG) for your web page and the imminent Accessible Rich Internet Applications (WAI-ARIA).

Excellent! Our HTML is neat, we’ve styled it, and all humans can interact with it. But what about the machines? They don’t understand our badly structured markup. If we want machines to be able to understand the content, we need to engage with the semantic web standards and Resource Description Framework (RDF). The UK public sector is keen on HTML+RDFa although this is not a W3C standard yet. You can query your RDF data set using SPARQL and define your ontology (formal representation of concepts and relations between them) using the Web Ontology Language (OWL, not WOL). While we’re at it, a related and very succesful standard which touches my world is the Dublin Core Metadata Standard, which is an ISO standard. I like this good introduction to Semantic Web standards if you want to read more.

The Biggest Standard of the Naughties

Extensible Markup Language (XML) is a hugely successful standard. If you judge the success of a standard by its adoption (which I do), it was the Hit of the Decade. XML Schema (XSD) has replaced the ill-thought-out DTD standard for defining XML structures. Other child standards include the node selection language XPath and query language XQuery. XSL Transformations (XSLT) is my favourite templating language. XML Inclusions (XInclude) joins XML documents together. They’ve also given us XForms to collect data – sadly it hasn’t taken off as I’d have liked.

Also XML related, the Web Services Standards have given us a wonderful way to make remote services play together. The Holy Trinity behind Web Services are SOAP (previously Simple Object Access Protocol) to define the message formats, Web Services Description Language (WSDL) to give service descriptions and Universal Description, Discovery and Integration (UDDI) to find the services. UDDI is actually an OASIS specification, not W3C, but it fits better here.

OASIS standards

OASIS (Organization for the Advancement of Structured Information Standards), in their own words, “drives the development, convergence and adoption of open standards for the global information society”. The OASIS standards that touch my world include, in no particular order:

My American dream
Fell apart at the seams.
You tell me what it means,
You tell me what it means.
- HEARTLAND

I am happy to join with you today in what will go down in history as the greatest vision for The Future of Content Management Systems.

Fifteens years ago, two great Americans, in whose symbolic shadow we stand today, created something. Ross Garber and Neil Webber’s product came as a great beacon light of hope to millions of Content Management editors who had been seared in the flames of unmanageable sites. It came as a joyous daybreak to end the long night of their tedious static HTML updates.

But fifteens years later, the CMS world is still imperfect. Fifteen years later, thousands of vendors are still sadly crippled by a lack of standard patterns, terminology, tools and concerns. Fifteen years later, CMS vendors still live on a lonely islands of in the midst of a vast ocean of potential standards. Fifteen years later, there still isn’t anyone who has done it properly. So we have come here today to dramatize a shameful condition.

I am not unmindful that some of you CMS vendors have come here out of great trials and tribulations. Some of you have code bases that are ten years old and will resist change at every turn. Some of you have lucrative clients locked in to long term contracts who will not be easily upgraded to new systems. Some of you have come from attempts to differentiate yourselves from your competitors that have left you battered by the storms of feature bloat and staggered by the winds of pricing wars. You have been the veterans of creative suffering. Continue to work with the faith that unearned suffering is redemptive.

Go back to Open Text, go back to Autonomy, go back to Microsoft, go back to SDL Tridion, Day, Alterian and Fatwire. Go back to the smaller commercial vendors and hordes of Open Source vendors, knowing that somehow this situation can and will be changed. Let us not wallow in the valley of proprietory isolation.

As we Separate the Concerns and Embrace the Standards, we must make the pledge that we shall always march ahead. We cannot turn back. There are those who are asking the devotees of standards, “When will you be satisfied?” We can never be satisfied as long as systems all use different names for the same thing. We can never be satisfied, as long as CMS vendors ignore their core features and focus on gimmicks for sales pitches. We cannot be satisfied when content migration from one system to another takes longer than building a house. We cannot be satisfied as long as as Content Management, Community, Analytics, eCommerce and more are moulded into a giant monolith instead of walking hand in hand like loosely coupled brothers.

I say to you today, my friends, so even though we face the difficulties of today and tomorrow, I still have a dream. It is a dream deeply rooted in the Content Management dream.

I have a dream that one day the vendors will rise up and live out the true meaning of interoperability: “We all need to work together to succeed, and those that don’t play will be left behind.”

I have a dream that one day all vendors will stop building exactly the same thing in slightly different ways, and that ridiculous templating languages will be replaced with the beauty of XSLT. And that repositories will not differentiate between data and metadata.

I have a dream that one day even the commercial vendors, who are often centres of innovation, will implement their systems using standard formats and will interoperate with open source tools. And let the best of these standard formats not start with a J and alienate more than half of the vendor community.

I have a dream that my four little children will one day log into every CMS system using their OpenID and avoid the perils of priopritary user databases.

I have a dream today.

Let logical, standard XML formats replace rigid, sparsely populated relational databases!

Let existing tools such as SVN or GIT release us from the limitations of badly implemented priopritary versioning systems!

But not only that; let these same versioning tools gives us virtualisation and deployment using branching and tagging!

Let authentication happen outside of the CMS. And let Workflow tools operate externally with any payload, not by adding an attribute to a content object.

Let freedom ring from every W3C validator and every WCAG recommendation. From every friendly URL and SEO ranking, let freedom ring.

Let freedom from vendor lock in ring from Austen, Texas to Stockholm, Sweden!

And when this happens, when we allow standards to pervade, when we let them ring from every commericial CMS and every Open Source CMS, from every XML format and every JCR specification and every CMIS binding and every new standard we so sorely need to produce, we will be able to speed up that day when all of God’s users, authors, developers, content migrators, administrators and system procurers, will be able to join hands and sing in the words of the lucky stakeholder who moved to a new CMS quickly and easily, “Free at last! free at last! thank God Almighty, we are free at last!”