Diving down rabbit holes


You know how it is. You start thinking about a problem. Then you start reading about that problem. And then the ‘trouble’ starts…

One thing leads to another and before you know it you’ve started a major research project all of your very own.

I recently started thinking about issues around integrating configuration management data across heterogenous platforms and tools. For many years I’ve felt that the solution to this problem would be found in semi-autonomous agents running in a peer-to-peer network (as one would), so, finding myself ‘between jobs’ I thought I’d dig into this problem a little. Sheesh!

I started a project (Omneity)—which I’m open sourcing—partly to get others involved but mainly to keep track of my own thinking. Anyway, I thought I’d make use of this time to play with some bits and pieces that would be generally useful in my professional life. Specifically, I’m using Git for version control, Maven for builds, Eclipse for my editor and Java for implementation. All technologies I’ve stumbled over in the past, but I could use the workout to deepen my understanding of these.

Turns out, that was the easy part.

I knew before hand that I wanted to make the Omneity system pluggable and capable or remotely distributing updates between agents. It didn’t take too long to settle on the OSGi framework as the way forward (so that got added to the list of ‘things to investigate’).

  1. OSGi framework

I also knew I wanted a lingua franca, a common exchange format for information about configuration management. After thinking about this for a while I realised I needed something very flexible to represent knowledge within the system and I settled on the semantic web, specifically RDF and OWL as things to look into.

  1. OSGi framework
  2. Semantic web: RDF & OWL

This led inevitably to a wider reading of knowledge representation (something I last looked at over twenty years ago during my undergraduate studies).

  1. OSGi framework
  2. Semantic web: RDF & OWL
  3. Knowledge representation

Also to reasoning and inference engines.

  1. OSGi framework
  2. Semantic web: RDF & OWL
  3. Knowledge representation
  4. Reasoners

Of course I also needed to look into peer-to-peer networks. I like the look of JXTA, so add that to the list of ‘things to investigate’.

  1. OSGi framework
  2. Semantic web: RDF & OWL
  3. Knowledge representation
  4. Reasoners
  5. P2P, JXTA in particular

Oh, databases. Distributed graph databases specifically, something I know next to nothing about. I like the look of Neo4J specifically, but I want to maintain some decoupling so I also want to use Blueprint as a generic interface.

  1. OSGi framework
  2. Semantic web: RDF & OWL
  3. Knowledge representation
  4. Reasoners
  5. P2P, JXTA in particular
  6. Distributed graph databases: Neo4J & Blueprints

There’s also other stuff relating to graph databases I need to learn, but put that to one side for now.

Having read about OSGi it became obvious that my Java skills were going to need a serious improvement (I’ve written very little Java from scratch, most of my work with JAva involves minor merging and build issue resolution on other people’s code). It also became apparent that I would need to learn a lot more about Java threads and class loaders. Add that to the list.

  1. OSGi framework
  2. Semantic web: RDF & OWL
  3. Knowledge representation
  4. Reasoners
  5. P2P, JXTA in particular
  6. Distributed graph databases: Neo4J & Blueprints
  7. Java threads and class loaders.

While reading around the whole knowledge representation and semantic web stuff a lot of the more academic papers involve mathematics. And my mathematics was too rudimentary to understand it all. Damn! Add that to the list.

  1. OSGi framework
  2. Semantic web: RDF & OWL
  3. Knowledge representation
  4. Reasoners
  5. P2P, JXTA in particular
  6. Distributed graph databases: Neo4J & Blueprints
  7. Java threads and class loaders.
  8. Discrete mathematics: set theory, graph theory, and probably group theory.

Then I got slightly side-tracked by a paper on complexity theory. Really?! Okay, I did some really basic stuff waaay back in my undergrad days, what the heck, it’s interesting stuff, let’s take a look (more math).

  1. OSGi framework
  2. Semantic web: RDF & OWL
  3. Knowledge representation
  4. Reasoners
  5. P2P, JXTA in particular
  6. Distributed graph databases: Neo4J & Blueprints
  7. Java threads and class loaders.
  8. Discrete mathematics: set theory, graph theory, and probably group theory.
  9. Computational complexity

Oh yeah, you remember all that semantic web stuff. Turns out developing ontologies is not that simple. Add that to the list (along with how to use Protègè).

  1. OSGi framework
  2. Semantic web: RDF & OWL
  3. Knowledge representation
  4. Reasoners
  5. P2P, JXTA in particular
  6. Distributed graph databases: Neo4J & Blueprints
  7. Java threads and class loaders.
  8. Discrete mathematics: set theory, graph theory, and probably group theory.
  9. Computational complexity
  10. Ontology development: using Protègè

So. A project that’s been bouncing around in my head for a few years has led to a substantial amount of work, mostly a very steep learning curve. Fortunately it’s all fun and interesting stuff (even if the math does make my head hurt).

How about you? Have you ever started something that has led from one thing to another until you realised just how much you had taken on?

, , , , , , , , , , , ,

  1. Leave a comment

Leave a Reply

Fill in your details below or click an icon to log in:

WordPress.com Logo

You are commenting using your WordPress.com account. Log Out / Change )

Twitter picture

You are commenting using your Twitter account. Log Out / Change )

Facebook photo

You are commenting using your Facebook account. Log Out / Change )

Google+ photo

You are commenting using your Google+ account. Log Out / Change )

Connecting to %s

Follow

Get every new post delivered to your Inbox.

%d bloggers like this: