Mihai Mobile

JSON is the new XML.

JSON, the “JavaScript Object Notation”, is a very simple notation for representing hierarchical data. It achieves what XML was supposed to do, and in a very simple way.

While the XML spec is hundreds (thousands?) of pages, the JSON spec fits comfortably on one page. Although the name suggest an association to JavaScript, JSON is in fact language-agnostic. There are JSON libraries for almost any language out there.

Sample JSON fragment:

{
"name":"John",
"tel":["+16051231234", "+48885003300"],
"address":{"street":"Dyamond 8", "city":"San Francisco"}
}

JSON has elementary values (strings, numbers; e.g. “foo”, 10), arrays marked by square brackets (e.g. [2, 4, 8]), and maps (also named ‘objects’) which contain key:value pairs between curly brackets (e.g. {“name”:”John”, “age”:”10″}).

Because of its simple and uniform structure, JSON is very simple to parse (this is a major advantage over XML). JSON is more compact then XML. JSON is more ‘pure’, more elegant than XML. And because of its ability of representing arbitrary complex hierarchical structures, JSON is just as powerful as XML.

While XML had all the hype, JSON is quietly getting the job done.

Follow-up: quite funny, only one day after I wrote this article, there was a similarly-themed post on CEO’s blog: JSON for data exchange (vs. XML).

I’ve just seen the new web application Jottit, and I liked the way they get simplicity right.

Because simplicity and elegance is not only in the way it looks, but also: in the size of the web pages, in the URL naming scheme, and most importantly in the interaction design.

About the web page size, do you know many sites with under-1KB size pages? To compare, what about sites with over-100KB size pages? Why would size matter — because more people are browsing the web on mobile phones; but also because simplicity and elegance mean minimalism, i.e. not to put on a page stuff that’s not needed. It doesn’t matter that the slack is not visible because it’s hidden inside the HTML source, having an unnecessarily large page is still a violation.

The URL naming scheme is of paramount importance, yet it’s surprising how much developers aren’t aware of this. I created a test page on Jottit, and it has the URL http://javia.jottit.com/. You can’t get the URL simpler than this. The URL must be short, semantic, and without arbitrary, meaningless parts in it. If you have to put some data key somewhere (in the URL or in a Cookie) make it short! Look at Jottit, when they put a page-code in the URL, it has 4 characters: http://jottit.com/xy4v/ .

Let’s compare: I was recently looking for where to host an open source project. Sourceforge.net is the venerable site, and I have respect for the good they did for many open-source projects, but the site IMO sucks. It is as complicated as it can get! I think they worked hard to put as much stuff as possible on as many pages as possible. And one of the smaller details: they also own the domain name sf.net, which only redirects to sourceforge.net. I can’t begin to understand why, having such an incredibly valuable domain name available, the 2-letter SF.net, they don’t use it. If my project was named let’s say “foo”, I’d love a domain name like “foo.sf.net”.

Google Code Project Hosting (I hope I got the official name right) is a breeze compared to Sourceforge, it is much simpler. Much better. I’d recommend GCPH (Google Code Project Hosting) to anybody over Sourceforge, if only for all the hassle you save yourself when creating a new project. Yet GCPH si far from perfect: they don’t get the URL naming scheme! Let’s consider a project named “menstral”, it will have this URL: http://code.google.com/p/menstral/, and the subversion repository URL http://menstral.googlecode.com/svn/. The problems with these URL names is: 2 different domain names (code.google.com and googlecode.com) inside a single project, and the redundant and arbitrary “p” in the project’s main URL. The URL for the project should have been http://menstral.googlecode.com.

The conclusion: bravo to Jottit for setting a new standarnd in simplicity and giving us an example. And I have a feature request for them: get HTTPS to work on all pages.

In Java, a class literal is a construct of the form String.class, which returns the Class object that corresponds to the named class. You can use this to test the exact class of an object, like this:

boolean isInteger(Object obj) {
  return obj.getClass() == Integer.class;
}

(A similar goal can be achieved by using instanceof, even though the semantics and the performance are not exactly the same.)

If you try to use the class literal on CLDC 1.0, it won’t work. You get at compile-time the rather funny error message

class file for java.lang.NoClassDefFoundError not found.

The explanation is that, up to and including Java 1.4, the class literal is emulated this way:

static Class class$java$lang$Integer;

static Class class$(String className) {
  try {
    return Class.forName(className);
  } catch (ClassNotFoundException e) {
    throw new NoClassDefFoundError();
  }
}

boolean isInteger(Object obj) {
  return obj.getClass() ==
    (class$java$lang$Integer != null ?
      class$java$lang$Integer :
      (class$java$lang$Integer = class$("java.lang.Integer")));
}

So the innocent-looking Integer.class is translated into a bunch of code, which can throw a new unchecked exception, NoClassDefFoundError. The problem is that CLDC 1.0 doesn’t provide this exception class, so you get a compilation error.

The solution? Use instanceof if possible. Another solution is to use a static final member initialized by calling getClass() on a dummy instance.

static final Class INTEGER_CLASS = new Integer(0).getClass();

A template is used to generate a text string based on some data parameters. A simple template for a letter:

Dear ${name},
please pay us ${amount} dollars.

You use a template like this:

letterTemplate = Template(templateString)
letter1 = letterTemplate(name='John', amount='100')
letter2 = letterTemplate(name='Tom', amount='200')

The template can be more powerful than simple text substitution, by using loops, conditionals, etc.

Hello ${name},
you ordered these ${len(items)} items:

{{for (i, item) in enumerate(items):}}
item ${i+1}: ${item}
{{end}}

Calling the template with some parameters

print template(name='Joshua', items=['bottled water', 'milk', 'icecream'])

generates this output:

Hello Joshua,
you ordered these 3 items:

item 1: bottled water
item 2: milk
item 3: icecream

How difficult is it to implement such a template engine? 60 lines of python code:

import cStringIO as StringIO
import re

_reExpr  = re.compile(r'\${(.*?)}')
_reCode  = re.compile(r'(?:\n *)?{{(.*?)}}')

class Adder():
    def __init__(self):
        self.indent = ''
        self.o = StringIO.StringIO()

    def incIndent(self):
        self.indent = self.indent + '  '

    def decIndent(self):
        self.indent = self.indent[:-2]

    def write(self, txt):
        self.o.write(self.indent + txt + '\n')

    def getvalue(self):
        value = self.o.getvalue()
        self.o.close()
        return value

def pairify(seq):
    it = iter(seq)
    while True:
        yield (it.next(), it.next())

class SimpleTemplate():
    def __init__(self, string, origin = None):
        string = _reExpr.sub(r'{{_o(str(\1))}}', string)
        parts = _reCode.split('{{}}' + string)[1:]
        adder = Adder()
        for (code, txt) in pairify(parts):
            code = code.strip()
            if code:
                if code == 'end':
                    adder.decIndent()
                else:
                    firstWord = code.split(None, 1)[0]
                    if firstWord[-1] == ':': firstWord = firstWord[:-1]
                    if firstWord in ['else', 'elif', 'except', 'finally']:
                        adder.decIndent()
                    adder.write(code)
                    if code[-1] == ':': adder.incIndent()
            if txt:
                txt = txt.replace('\\\\', '\\\\\\\\').replace('"', '\\\\"').replace('\\n', '\\\\n')
                adder.write('_o("' + txt + '")')
        source = adder.getvalue()
        self.code = compile(source, origin if origin else source, 'exec')

    def __call__(self, **varMap):
        output = StringIO.StringIO()
        varMap.update(_o = output.write)
        exec self.code in varMap
        content = output.getvalue()
        output.close()
        return content

Among the first things I’ve been imprinted with at Google, is that Google is a very secretive company. I’m not allowed to tell almost anything about [the inside of] Google. I don’t even know how I could ever post anything mentioning the word Google on my public blog, but given that I’ve read public blogs of other googlers, I imagine that just blogging may not be a reason for immediate firing. Just for caution, I’ll try to restrict myself to saying only positive things about Google (and this does not imply that there are other-than-positive things to be said about Google) — self-censorship is an interesting attitude.

First, I should stress that there are plenty of great things about Google — the problem is that many of these are already well known (not to mention the food).

My first contact with the inside of Google was through the interviewing process (when I was recruited). I can tell that I was positively impressed by the interviewing process: most of the questions/tasks were relevant and challenging, and the people conducting the interviews seemed compentent and smart. I also had the impression that they were looking for objective hints in order to evaluate my skills (as oposed to subjective judgement). As a simple outline of the interviewing process, I started by sending my Resume (CV) by email to Google. After this followed two phone-screens, and afterwards, four in-person interviews.

What can I say, I’d wish to become as good an interviewer as some of the persons who interviewed me. But there is one small thing that keeps me from being completly extatic about the recruiting process at Google: about a year and a half ago, I sent for the first time my resume to Google. It was not exactly the same resume, and the layout was different, but it was essentially describing the same person (me).

Back then, I got back the standard refusal email, we have no oppenings matching your skills at this time or something like this, but I think that the real message of the email was: based on your resume, we decided it’s not worth proceeding to the phone-screen phase. Meaning that the recruiter was so confident that I’m a bad candidate, that it didn’t warrant a phone-screen test.

I don’t really believe that I improved that much between then and now. I rather think that I experienced a glimpse in the recruitment process: either Google hired a bad candidate now, or the recruiter hurried to drop my resume back then — I hope it’s the last. Of course, Google (like some other companies) is more concerned about avoiding a bad hire than about losing a good candidate — or in other words, a false-negative is preferred to a false-positive. From the employer perspective, it’s preferrable to err on the side of caution; what I’m surprised is that my resume was judged so bad that I didn’t even make it to the phone-screen.

PS: if you’re interested in a software development position at Google, you may be better-off sending your resume (CV) to a Google employee you know for them to refer you, rather than doing a spontaneous application. And second, Google is hiring in (extended) Europe and Russia, so don’t be put-off if you don’t live in the US.