Mastering the Tao of Personal Computing

I’m writing this blog post for the very same purpose I’ve decidedly written my latest university paper in English. I just want to reach the biggest possible audience in attempt to introduce you an idea that has the potential to change drastically the way we write software.

HERE YOU CAN DOWNLOAD MY PAPER

Prolog

Just as always when I have to write a paper for the university, I take the assigned topic and turn it into something completely different. And that’s exactly what I did for my Middleware paper.

My assignment was to write about Ontologies and Ontology Languages for Web Service Description, but it ended being a paper about reassessing the role which formality plays in the field of software engineering.

So, how did I got from there to here?

At the start, my intention was to take a couple of ontologies for web service description and to make an attempt to evaluate them according to a set of design criteria, as described in one of the most widely cited works in ontology - Thomas R. Gruber, Toward Principles for the Design of Ontologies Used for Knowledge Sharing.

But guess what? It doesn’t work that way. And it won’t work that way, especially when you don’t have enough time. And what do I mean by that?

The Impenetrable Citadel of Concentric Formality

As soon as I started my acquaintance with one of the ontologies I’ve picked, I realized that I don’t know enough and that I need to get familiar with the underlying layer. When I started to get to know the thing underneath, same sh*t happened. I just couldn’t move on without picking into the layer beneath. Getting two floors down and I couldn’t remember anymore what was two floors above.

I’ve always considered layering a good thing, but what was happening then? Why I’m not able to learn about a system one layer at a time, without having to pick into the layers beneath? And it just struck me:

All these layers of effective formality all the way down are simply inefficient…

…And it is inefficient not because it isn’t precise, but because it is maybe too precise.

Why growing an interest in Lisp may matter?

When you grew an interest about something, interesting things will start to happen to you. Things like discovering new stuff, discovering new ideas and most importantly discovering new amazing people. Scheme is probably the most amazing programming language I’ve learned in the university, but I haven’t been manifesting any forms of interest in Lisp until recently. And that’s how I discovered the work of Gregor Kiczales - the creator of the Meta-Object Protocol for Lisp, the father of CLOS and the mind behind the Aspect-Oriented Programming. And one of the first things I did was listening to his keynote talk at OOPSLA 2007 (available as podcast and PDF slides). Since then I’ve been listening to this same talk at least three more times. This talk is all about formality vs. informality and it ended being a road-map for my Middleware paper. A substantial part of the audio you can find almost as a transcript in my paper. I’ve been shamelessly repeating Kiczales’ words with the hope they will raise some interest in these radical ideas.

Disclaimer

In advance, I want to apologize to all the experts that are familiar in much more detail with the stuff I wrote about in my paper. To them it may seem that I’m just scratching the surface, and probably they’re right. Forgive me, if I haven’t presented your ideas in the right way, or if I’ve misunderstood you. If that’s the case, it would be great if I hear back from you.

This post is tagged informality, ontology, paper