I have been studying and working with web standards (XHTML, RDF, ATOM, RSS) for well over 4 years now, something I am glad of,  because recently something struck me. Conventions are arising, for example DOAP, SKOS and others, that are built on top of the Resource Description Framework otherwise known as RDF, if they aren’t, they are usually built on something very similar or related.

In this blog post I am going to be using the FOAF standard as an example and base for my proposal. First of all, the Friend Of A Friend standard (FOAF) is a project aimed at creating machine readable pages that describe people. It covers all basis of human interactions and behaviours. From basic profile information - name, mailbox, title, homepage, img, depiction, surname, given name, family name, firstname - to more detailed information as such as web blog, based near, geekcode, publications, etc.  As you can see on their standard description page, it also covers the following personal aspects: Online Account / IM, Projects / Groups and Documents and Images.

For instance, if a web application was to describe me using FOAF it could look something like this:

1
2
3
4
5

<foaf:Person rdf:about="#davidc" xmlns:foaf="http://xmlns.com/foaf/0.1/">
  <foaf:name>David Coallier</foaf:name>
  <foaf:homepage rdf:resource="http://echolibre.com" />
  <foaf:img rdf:resource="/images/david.jpg" />
</foaf:Person>

The Problem

Whilst such a standard is clearly easy for a computer to read and does seem a logical fit, it’s not the easiest for a developer to read. These days, web users are looking for performance, simplicity, ease of use, and so are the developers creating web applications. Considering that XML is heavy to parse using current technologies (Javascript mostly), it makes very little sense for developers to make web applications that are going to be slower due to parsing complex XML nodes. However, JSON (JavaScript Object Notation) is a lightweight data-interchange format made to carry data over networks with a very small footprint. It has seen massive adoption across the web and is used in widget apps, web apps and various other systems.

As I was talking at OSS Bar Camp, something struck me. Developers need a standard. Fact. We need standards for the same reason the industrial revolution had need of machine part standards: to reduce the amount of different solutions to learn in order to achieve the same goal by having everyone do what they do in a standard way. Some may see standards as a way to prevent innovation, I see them as a way to innovate. See “why are web standards important” by the W3C, a good read.

So, developers need standards. Great, now what currently exists? Development standards (IDE, Documentation, tools, design patterns, unit testing, etc.), Output standards (XHTML, CSS, etc), XML based standards (Namespaces, Schemas, XPath, XQuery, XSLT, DOM, XML Base, RDF(s), etc.), usual web architectural principles, and many more. One thing that is missing though is the standards that allow developers to easily and rapidly work with each other’s web application.

If “Web 2.0″ was characterised by the democratisation of content, we feel strongly that the next stage of web evolution, “Web 3.0″ for want of a better word, will be characterised by the democratisation of data and applications.

The Solution

A standard would make that democratisation a little easier. I’ve decided that I am going to be working on this over the next few months with the help of a few others as such as Ed Finkler from the CERIAS (Also the creator of Spaz and all round awesome guy).

So, today I’m putting forward the need for PJFS - The Practical JSON Format Standard. It will strive to make heavy XML based standards more developer friendly and lighter by creating new, fresh and adapted Practical JSON Formatted Standardized outputs.

For instance, the FOAF example I drew above, is a great example of the need for PJFS. Consider the following from a developers perspective:

1
2
3
4
5
6
7

{
    "Person": {
        "name":"David Coallier",
        "homepage":"http:\/\/echolibre.com",
        "img":"http:\/\/echolibre.com\/images\/david.jpg"
    }
}

It’s easy to read but also easy to parse. It’s fast and reliable. I am well aware of the implications of this post and I do not underestimate the complexity of existing standards. I think each one of them, as complex as they can be, are needed and are something we should all aim to use. However, computers are not completely independent ( just yet!) and the middlemen (developers and users) should not be forgotten.

The implications of JSON formatting standards mean that it’s adoption will make things easier for developers by reducing the amount of work they have to do, and remove the learning curve on new object structures for every web service the want to use.

The first task I will start working on is a PJFS for micro-blogging web services. The likes of identi.ca have already started in the general direction by “copying” the behaviours of the Twitter API, however many other micro-blogging platforms are still very independent and a unified standard could help the tools developers creating more flexible tools that would cover more networks.

So, remember where you heard about PJFS first It’s there to create standard object names, properties, variables, class members names to JSON elements so that developers can expect something identically formed when requesting JSON information from a webservice.

If you’d like to be involved leave a comment or catch me on twitter - @davidcoallier.

Our new office can be found at 19 Greek Street (W1D 4DT), which currently houses a few other startups (Hmmm….wondering should it be renamed Geek Street?)  - all thanks to Irish entrepreneur Paul Walsh. But some space in an office does not a company branch make. So, we’re delighted to welcome to echolibre Helgi Þormar Þorbjörnsson.

Helgi comes with the right amount of PHP kickassness that we expect at echolibre; Helgi wirtes for PHP | architect magazine, and being a member of the PHP PEAR Group also rocks. Helgi will be heading up R&D and working with our UK clients, so we’re excited to see what happens in the next few months. We are also looking forward to connecting with the vibrant PHP and Open Source communities in London.

Today, myself and David are off to London for a bunch of meetings, and to meet the rest of the dudes at 19 Greek St.

If you’re a UK based startup and you need a fresh injection of PHP talent to your web app or development team, get in touch on freedom@echolibre.com. If you want to contact me directly, you can skype me on eamon.leonard.

*Yes, any excuse to play some Elvis Costello.

Anyone who’s been working in web tech for any length of time will get what I’m saying here: that it’s a given that you can reach out with a message through what ever online medium you want to someone you’ve never met before and get something back.

Indeed, echolibre was formed as a result of a tweet sent to me by Jan Lehnardt (@janl) in June 2008. That tweet led to a conversation over a pint of Guinness in the Sean O’Casey with David Coallier,  and prompted me in asking him to startup echolibre with me.

So, it is with this spirit of open communication and networking that myself and David are really looking forward to traveling to London next week to meet with members of the PHP Community there. PHP London are running their monthly meetup, and we’re delighted to be going. I know David is looking forward to meeting up with Helgi Thormar from the PEAR Group and Scott MacVicar of SQLite and the PHP Core
development team.

As it happens, there’s another event going on only a short distance away, that we’re also going to. Open Soho [facebook group link],  which is  “An informal fortnightly meet-up in Soho for people working in the tech & media industries in London.“, is on the same night and I believe is drawing a big crowd, 220 at the last count.

All in all, it think it will be a great trip. If you’re going to be at either PHP London or OpenSoho make sure you find us and say hello!