Clay Shirky’s latest newsletter) on networks, economics and culture discusses the semantic web. In a nutshell, he’s not very impressed. The starting point for this argument is that syllogisms don’t model the real world well, an example:

The creator of shirky.com) lives in Brooklyn. People who live in Brooklyn speak with a Brooklyn accent.

Well in this case clearly they don’t, the second assertation is clearly false, it’s obvious that not everybody who lives in Brooklyn calls birds boids, so that absolute assertaion does not hold.

The example later on using Nike and the first amendment of the US constitution has more merit, in this case the fact asserted (the first amendment covers the rights of US citizens) is a subset of the actual applicability rather than a superset as in the Brooklyn case. I think that this is still a surmountable problem, but it may require a more complex representation of ‘facts’ than initially considered. I think that maybe the way forward if not, as Clay suggests (if only to point out it’s impracticality), to attach context to each assertation and then cross check against this.

A better approach surely would be to attach an accuracy value to each statement, then the syllogisms could have attached accuracy values also. For example, the following pseudo code:

1
2
3

LET clay lives in Brooklyn ACCURACY 1.0
LET people who live in brooklyn say boids ACCURACY 0.7
DEDUCE clay says boids ACCURACY 0.7

With the final 0.7 being the product of the two ‘fact’ accuracies. Now this is just something that I’ve come up with on the spur of the moment, not a result of research so I don’t know how generally useful this would be, but in tools designed for human use it should be possible to tolerate a level of inaccuracy, so long as it is marked as such.

Reading further, the examples about merging databases I can agree with the fact that it’s way more complicated that just simply mapping field names! When it comes to meta data, this is probably best if it can be extracted from the data itself automatically, of course this would reduce the amount of available data, but maybe we could tag any manually added meta data with a date and allow it’s accuracy to deteriorate as time goes by (or as the tagged data is revised), and you could always tweak your reasoner to reduce the accuracy of human added data anyway.

Hmmm, but this goes against what the semantic web is supposed to be for to a large extent. Machines need to be able to rely on absolute (i.e. ACCURACY 1.0) facts to be able to use them a lot of the time. I think the conclusion that I’m coming to is that there is a benefit to be gained from the semantic web and it’s related technologies and ideas, but probably not as great as it’s champions make out.

So it’s another web related technology with potential that has been overmarketed. Nothing new there then.

I’ve been playing a little with learning Lisp (not that I’ve much free time, but hey, what the hell). This example, taken from Dave Lamkins’ Successful Lisp), more than any other that I’ve seen so far, expresses the power of the language.

1
2
3
4

(defun open-bracket (stream char)
  `,(read-delimited-list #] stream t))
(set-macro-character #[#'open-bracket)
(set-macro-character #] (get-macro-character #)))

Here’s what’s happening: we’re redefining the syntax of the language dynamically! Normally, if I type [1 2 3] into a Lisp interpreter it will raise an error, something along the lines of variable [1 has no value, but after running that little code snippet I can now type [1 2 3] and it will create a three element list populated with the numbers 1, 2, and 3. Here’s the equivalent in a Java like syntax.

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23

class OpenBracket implements JavaLanguageParser {
    static List list;
    public void nextToken(RuntimeEnv env, StreamTokenizer stok) {
        if (list == null)
            list = new ArrayList();
        int tok = stok.nextToken();
        if (tok == TT_WORD)
            list.add(stok.add(stok.sval));
        else if (tok == TT_NUMBER)
            list.add(new Double(stok.nval));
    }
}
class CloseBracket extends JavaLanguageParser {
    public void nextToken(RuntimeEnv env, StreamTokenizer stok) {
        if (OpenBracket.list ==null)
            throw new ParseException("mismatched brackets");
        env.pushObjectOntoStack(OpenBracket.list);
        OpenBracket.list.clear();
        OpenBracket.list == null;
    }
}
Lang.defineNewKeyword("[", new OpenBracket());
Lang.defineNewKeyworkd("]", new CloseBracket());

Then writing List foo = [1 2 3 bar] would yield a new ArrayList populated with 3 Double objects and a string. Even with my friendly psuedo-code it’s a lot more work, but to actually do this is impossible.

I assume that this is what folks like Paul Graham mean when they say things like ‘If you re writing a text-editor, you can turn Lisp into a language for writing text-editors. If you re writing a CAD program, you can turn Lisp into a language for writing CAD programs’ and it strikes me as an amazingly powerful concept. I think I really like this language.

I was walking past St. Pauls cathedral yesterday and it is currently wrapped in scaffolding. Rather than leave this in plain view, some bright spark has come up with the idea of wrapping a big sheet of cloth around it with a pencil sketch of the cathedral on it. How gypped would you feel if you’d just trekked half way across London just for that!

I had a look at the Java Help API today, hoping to use it in an application that I’m writing, alas no. Despite claiming to be interface based, and coming with a reference implementation from Sun, what we now call the service provider pattern, it’s irrevocably tied to Swing. This means that you couldn’t use it to say, provide a help system on an interactive web based system, or an SWT based client side app, which is what I’m interested in.

Sun seem to be more interested in pushing their own ideas onto others than in producing a solid solution. Here’s hoping version 3 of the API solves this, but don’t hold your breath.

Ned Batchelder had a pointer to this article by Richard Gabriel entitled ‘Objects have Failed’. As usual Richard has some excellent points, but there are a couple of things that irk me about the piece.

About the failure of reuse: it hasn’t. Failed that is. In fact, reuse has been very successful. A single example makes this abundantly clear: the Java class libraries. I think that this idea that reuse has failed comes from some of the over hyped rhetoric that was bandied around in the early days of OO, but this is like saying that the Internet has failed because it didn’t fulfil the dreams that people talked about at the height of the dot com boom.

The Feyerabend Project gets a mention again. Some valid points, but I don’t really have time for a project that so far just seems to be a list of ‘things we do not like’. When (if?) it finally produces some concrete proposals on how to imporove things then I’ll take notice.