Shelter

Tech, philosophy and random musings

15 October, 2009 by Alex

Ontological Ponderings

The last few months have been interesting for me in a philosophical sense. My job is on an architectural level in using ontologies in software development, both in the process (development, deployment, documentation), the infra-structure (SOA, servers, clusters) and the end result of it (business applications). So needless to say, I’ve been going a bit epistemental, so I promised myself yesterday to jot down my thoughts and worries, if for no other reason than for future reference.

One big thing that seems to go through my ponderings like a theme, is the linguistic flow of the definition language itself, in how the mode of definition changes the relative inference of the results of using that ontology over static data (not to mention how it gets even trickier with dynamic data). We usually say that the two main ontological expressions (is_a, has_a) of most triplets (I use the example of triplets / RDF as they are the most common ones, although I use Topic Maps association statements myself) defines a flat world from which we further classify the round world. But how do we do this? We make up statements like this ;
Alex is_a Person
Alex has_a Son
Anyone who works in this field understand what’s going on, and that things like “Alex” and “Person” and “Son” are entities, and defined with URIs, so actually they become ;
https://shelter.nu/me.html is_a http://psi.ontopedia.net/Person
https://shelter.nu/me.html has_a http://en.wikipedia.org/wiki/Son
Well, in RDF they do. In Topic Maps we have these as subject identifiers, but pretty much the same deal (except some subtleties I won’t go into here). But our work is not done. Even those ontological expressions have their URIs as well, giving us ;
https://shelter.nu/me.html https://shelter.nu/psi/is_a http://psi.ontopedia.net/Person
https://shelter.nu/me.html https://shelter.nu/psi/has_a http://en.wikipedia.org/wiki/Son
Right, so now we got triplets of URIs we can do inferencing over. But there’s a few snags. Firstly, a tuple like this is nothing but a set of properties for a non-virtual property and does not function like a proxy (like for instance the Topic Maps Reference Model do), and in transforming between these two forms gives us a lot of ambiguity that quickly becomes a bit of a problem if you’re not careful (it can completely render inferencing useless, which is kinda sucky). Now given that most ontological expressions are defined by people, things can get hairy even quicker. People are funny that way.
So I’ve been thinking about the implications of more ambiguous statement definitions, so instead of saying is_a, what about was_a, will_be_a, can_be_a, is_a_kindof_a? What are the ontological implications of playing around with the language itself like this? It’s just another property, and as such will create a different inferred result, but that’s the easy answer. The hard answer lies between a formal definition language and the language in which I’m writing this blog post.
We tend to define that “this is_a that”, this being the focal point from which our definition flows. So, instead of listing all Persons of the world, we list this one thing who is a Person, and moves on to the next. And for practical reasons, that’s the way it must be, especially considering the scope of the Semantic Web itself. But what if this creates bias we do not want?
Alex is_a Person, for sure, but at some point I shall die, and then I change from is_a to a was_a. What implications will this, if any, have on things? Should is_a and was_a be synonyms, antonyms, allegoric of, or projection through? Do we need special ontologies that deal with discrepancies over time, a clean-up mechanism that alters data and sub-sequentially changes queries and results? Because it’s one thing to define and use data as is, another completely to deal with an ever changing world, and I see most – if not all – ontology work break when faced with a changing world.
I think I’ve decided to go with a kind_of ontology (and ontology where there is no defined truth, only an inferred kind-system), for no other reason that it makes cognitive sense to me and hopefully to other people who will be using the ontologies. This resonates with me especially these days as I’m sick on the distinction people make between language and society, that the two are different. They are not. Our languages are just like music; with the ebb and flow, drama and silence that makes words mean different things. By adding the ambiguity of “kind of” instead of truth statements I’m hoping to add a bit of semiotics to the mix.
But I know it won’t fix any real problems, because the problem is that we are human, and as humans we’re very good at reading between the lines, at being vague, clever with words, and don’t need our information to be true in order to live with it. Computers suck at all these things.
This is where I’m having a semi-crisis of belief, where I’m not sure that epistemological thinking will ever get past the stage of basic tinkering with identity in which we create a false world of digital identities to make up for any real identity of things. I’m not sure how we can properly create proxies of identity in a meaningful way, nor in a practical way. If you’re with me so far, the problem is that we need to give special attention to every context, something machines simply aren’t capable of doing. Even the most kick-ass inferencing machines breaks down under epistemological pressure, and it’s starting to bug me. Well, bug me in a philosophical kind of way. (As for mere software development and such, we can get away with a lot of murder)
I’m currently looking into how we can replicate the warm, fuzzy impreciseness of human thinking through cumulative histograms over ontological expressions. I’m hoping that there is a way to create small blobs of “thinking” programs (small software programs or, probably more correctly, script languages) that can work over ontological expressions without the use of formal logic at all (first-order logic, go to hell!) that can be shared, that can learn what data can and can’t be trusted to have some truthiness. Here’s to hoping.
The next issue is directional linguistics, in how the vectors of knowledge is defined. There’s things of importance to what order you gain your knowledge, just like there’s great importance in how you sort it. This is mostly ignored, and the data is treated as it’s found and entered. I’m not happy with that state of things at all, and I know that if I was taught about axioms before I got sick of math, my understanding of axiomatic value systems would be quite different. Not because I can’t sit down now and figure it out, but because I’ve built a foundation which is hard to re-learn when wrong, hard to break free from. Any foundation sucks in that way, even our brains work this way, making it very hard to un-learn and re-train your brain. Ontological systems are no different; they build up a belief-system which may prove to be wrong further down the line, and I doubt these systems know how to deal with that, nor do the people who use such systems. I’m not happy.
Change is the key to all this, and I don’t see many systems designed to cope with change. Well, small changes, for sure, but big, walloping changes? Changes in the fundamentals? Nope, not so much.
We humans can actually deal with humongous change pretty well, even though it may be a painful process to go through. Death, devastation, sickness and other large changes we adapt to. There’s the saying, “when you’ve lost everything, there’s nothing more to lose and everything to gain”, and it holds remarkably true for the human adventure on this planet (look it up; the Earth is not really all that glad to have us around). But our computer systems can’t deal with a CRC failure, little less a hard-drive crash just before tax-time.
There’s something about the foundations of our computer systems that are terribly rigid. Now, of course, them being based on bits and bytes and hard-core logic, there’s not too much you can do about the underlying stuff (apart from creating quantum machines; they’re pretty awesome, and can alter the way we compute far more than the mere efficeny claims tell us) to make it more human. But we can put human genius on top of it. Heck, the ontological paradigm is one such important step in the right direction, but as long as the ontologies are defined in first-order logic and truth-statements, it is not going to work. It’s going to break. It’s going to suck.
Ok, enough for now. I’m heading for Canberra over the weekend, so see you on the other side, for my next ponder.

Filed Under: Ontology, Philosophy, Topic Maps

5 August, 2009 by Alex

Can I ask you a favour? (Does social media actually work?)

Hi everybody. Could I ask you a favour? I’m not getting much response to my quest for a unified software architecture ontology, so could I humbly ask you to blog, tag, link or otherwise gossip about my previous post on the matter? I would really appreciate it, and I promise I’ll share my findings with you all.

(My subtitle “Does social media actually work?” is a blatant attempt to get circulation going by mocking the whole debacle which I try to, ahem, you know, promote. Thanks.)

Filed Under: Blogging, Ontology, Topic Maps

29 July, 2009 by Alex

Missing ontological serinity in the world of software systems architecture

Updates: See bottom, but also this question on StackOverflow.


Ok, so let me say from the get go that I’m a little bit upset. Well, maybe angry and bewildered more than upset, but nevertheless not happy. And it all has to do with the dingbat way we architecture our various computer systems. So, yeah, quite generic and not really something we can do much about.

Let’s rehash. I’m a SOA junkie, an EDA pimp, and I hate by default the bullshit in any Enterpise camp that promotes their way of doing must be right. And by SOA, I don’t mean no ESB bullshit, I mean a hard-core focus on services for architectural means. I build ontologically driven systems, and care deeply about semantics where most others don’t give a monkey’s bottom.

Lately I’ve had to rehash my knowledge on plugin architectures (both implementation specific and theoretical), how to modularise complex pieces of software, and implement an event-driven platform on which to run my systems. So I’ve been snooping around, and there’s a ton of models and architectures to be found. But being found is not the same as finding what you’re after, especially as I have a few criteria to my search; I want to find something that’s generic, simple (but not simplistic), elegant (as in, does not suck) and extendable, an architecture that’s event-driven, modular and open. Nothing. I’ve found nothing. Of course they all claim to be amazingly fantastic and super and great, but looking under the hood, if allowed, reveals yet another staticly created shared library stack with some hooks for your software to use, using some misnomer like SOA or EDA or any of the hundreds of other Enterprise bullshit terms out there.

So, I set my goals lower in the hopes of finding anything of value, even went and asked real programmers what I thought was a simple question, making it specific enough to hopefully muster some replies. Nothing. It seems everybody’s got their own way to handle their own little piece of the universe, that people cling to their silos of comfort or something, afraid of what might happen if we all agreed on something. Even when you dig into large architectures, like my own Linux Kernel which I’m using to write this post, there’s tons of layers and shared libraries that’s hubbled together in a way that does the job, ok, but doesn’t make it, in my eyes, an easy job to do, elegant to extend or easy to change.

I guess I should clarify. I’m knee-deep in ontology work for software systems architecture, a field that’s almost chemically free of any active community, has a few scattered experiements that went no where (and I’m tempted to put ADL in that category, too), a few papers here and there that talks about it in very generic terms (either as abstracts to academic stroke sessions, or a white paper claiming to be the second coming of Jeebus!), but as to hard-core practitioners like me who want to inject a Topic Map with events of given types that matches certain ontological expressions and Topic Map fragments of certain types of architectual patterns, tough! You’re on your own, kid.

So, what am I after?

Well, many things, but I’ll try to be a bit clear here. I’ve cut down on my wants, to, in order to try to find others out there doing similar things. So. I’d like to see a simple event-driven software stack that scales ontologically, and isn’t bound to any technology, company or otherwise religious platform. This means that the stack with its names and values work just as well for a small plugin as it does for a larger system like an extra-OS or a cloud, works for potato-peelers as well as online booking agents, database connection pools and kernel space memory managers, but also can grow and shrink with need, in such a way that all other parts of it when they need to can find out what those changes are. This digs into creating an upper ontology for information science, of course, but more importantly it means I’d like to plug software into various parts of a stack, so that everything – and I mean everything! – is an event listener. I know some micro-kernels work in similar ways but highly statically bound, but regardless these ideas are way past the cradle stage by now and need to have a greater exploration in the real-world.

So when I download an open-source package of sorts and try to find out what its stack of operation looks like, why is this information so hard to find? Or compare the Java event model and the .Net model. Or OSes. It seems it’s very hard to agree on these things, but I doubt the state of things isn’t because they’ve tried and failed, but because they haven’t tried. It’s a big world and this is a big field, yet this has not been tried in any meaningful way.

Sure, the technologies promoted through OASIS, ECMA and W3C in themselves have various solutions and tries to bind stuff together in a coherent way as not to confuse us too much, but even within their own stacks of proposals and standards there are huge gaps, great leaps of faith, and generally no clear direction. Even W3C who pushes the semantic web movement hasn’t got anything to say on the matter. It’s starting to drive me bonkers.

Ok, I’m done. My steam has gone out, but I’m not feeling any better. Off to do my own thing, like the rest of them. 🙂


Update: Ok, it seems I’m not getting my message across. Let me create a simple (and wrong) example ;

  • SOA : Start
  • SOA : Configure
  • SOA : Map
  • ENV : Start
  • ENV : Configure
  • ENV : Map
  • APP : Start
  • APP : Configure
  • APP : Init
  • APP : Connect
  • APP : Perform
  • APP : Teardown
  • ENV : Teardown
  • SOA : Teardown

Here we got an application session events where SOA is, er, SOA, ENV the “environment” (whatever that should mean), APP is an application, and so forth. This list should be HUGE! Think of all the interesting events one could generate from you turn the computer on until someone gets Rickrolled on the other side of the planet! I want to map environments, systems and eco-systems, with labels. In some regards it’s an enumerated list of points that any computer system traverses on its path from being loaded into memory until it leaves it. And possibly then some.

I want to map the software system world! I want to know what people call their various points on the software stack, what they call their events, how they see them work together, how they forsee workflow interactions, how they define system integrity, thoughts on implementation, named entities, the works.

I can find heaps of this stuff, but none of it is globally agreed upon, it’s all tucked away in projects or companies, it’s their own version of how things should be and what happens. Even big players such as Sun / Java and Microsoft / .Net have very different event models and ontologies, and they are not compatible in any meaningful way. I would expect some parts of CORBA had done work in this area, but what I’ve seen is very transaction oriented where clients already know the ontology and uses CORBA to travel through rather than be defined by.

As an example of the closest I’ve found so far in the realm of mapping machine-parts (“machine” here is “software systems”) is the Open architecture computing environment which tries to define up the most important parts of software systems (although the final version was released in 2004 … these things can be considered to be final? Where’s the clouds?), but lacks the ontological and semantic definition, has no event or message structures or standards, nor does it have any notational value or end-points which, admittedly, I could spend the next couple of weeks doing, but let’s see what else is out there.

Making any sense?


Update: To be even more specific, trawling through IPC is really what I have been doing for the last few days, but getting to the core ontology of all of this is soooo painful. Surely someone out there have done something like this? I’ve even gone through POSIX trying to gleam what nuggets I could find, but the system level of that beast is just so low it’s not funny. Promising is the DBus architecture and event stack, but this again is very low-level, covers only a fraction of the software systems, and is littered with duplication of complexities.

Anything else I should hack at? Yes, I’ve gone through the most of the WS-* stack as well, digging into past knowledge I had hoped to never see again, but here as well as most other technologies out there they seem to be obsessed with being so flexible that they forget to be defining. So, we get a lot of scaffolding and frameworks that you can extend and define your stuff in, but no clear definitions of what the world looks like. Even an obvious contender like WS-Events and the less-know WS-Event from Hewlett-Packard have nothing more than a functional approach to defining and registering events but that’s it, leaving the defining to some semi-ontological layer.

But I’m still convinced lots of people have done this sort of work, especially in these Semantic Web haydays. Browsing through the thousands of OWL ontologies in Swoogle for ‘software architecture’ (which doesn’t really cut it, but is the closest term that yield results) leaves me just overloaded. Sure, the OpenGroup SOA ontology for example, does provide me with, eh, lots of interesting stuff, but again it’s a special domain (SOA, obviously) using a certain moniker (service orientation, which sucks when you want to define events across operational stacks).

Argh! Can you tell I’m going bonkers?

Filed Under: Ead, Ontology, Soa, Soa Roa Woa Rest Soap Ws Architecture

Recent Posts

  • Another bob
  • Another tidbits
  • Philosophical and religious matters
  • Do libraries understand the future? Or how to get there?
  • Before I write what I write before the next time I write

Archives

  • April 2010
  • March 2010
  • February 2010
  • December 2009
  • October 2009
  • September 2009
  • August 2009
  • July 2009
  • June 2009
  • May 2009
  • April 2009
  • March 2009
  • January 2009
  • November 2008
  • October 2008
  • September 2008
  • August 2008
  • July 2008
  • June 2008
  • May 2008
  • April 2008
  • March 2008
  • February 2008
  • January 2008
  • December 2007
  • November 2007
  • September 2007
  • August 2007
  • June 2007
  • May 2007
  • April 2007
  • March 2007
  • February 2007
  • January 2007
  • December 2006
  • November 2006
  • October 2006
  • September 2006
  • August 2006
  • July 2006
  • June 2006
  • May 2006
  • March 2006
  • October 2000

Categories

  • Alsa
  • Application Design
  • Australia
  • Baroque Music
  • Biology
  • Blogging
  • Book Review
  • Business
  • Canberra
  • Chemistry
  • Coaching
  • Communication
  • Conceptual Models
  • Conference
  • Context
  • Cooperation
  • Cosmology
  • Creationism
  • Crows
  • Cute
  • Data Modelling
  • Data Models
  • Debt
  • Dune
  • Ead
  • Ecology
  • Elegant Code
  • Emnekart
  • Environmentalism
  • Everything
  • Evolution
  • Family
  • Film
  • Food
  • Frameworks
  • Fstl
  • Future
  • General
  • General Life
  • Globalism
  • Grace
  • Happiness
  • Harmonica
  • Holidays
  • Humanity
  • Ia
  • India
  • Indiana Jones
  • Intelligence
  • Java
  • Jobs
  • Juggling
  • Kiama
  • Kids
  • Knowledge Representation
  • Kuala Lumpur
  • Language
  • Laptop
  • Leipzig
  • Library
  • Life
  • Life Lessons
  • Linux
  • Localivore
  • Lucas
  • Marcxml
  • Misc
  • Monteverdi
  • Mood
  • Movies
  • Music
  • Music Production
  • Norway
  • Ontology
  • Ooxml
  • Open Source
  • Oslo
  • Oslo Domkor
  • Oss
  • Philosophy
  • Php
  • Planning
  • Programming
  • Programming Languages
  • Proud
  • Rdbms
  • Real Estate
  • Rental
  • Rest
  • Richard Dawkins
  • Salut Baroque
  • Sam
  • School Closures
  • Semantic Web
  • Semantics
  • Soa
  • Soa Roa Woa Rest Soap Ws Architecture
  • Sound
  • Spielberg
  • Status
  • Stupidity
  • Systems Thinking
  • Talk
  • Technology
  • Terje Kvam
  • Test Driven Development
  • Tidbits
  • Tmra
  • Tmra 2008
  • Topic Maps
  • Ubuntu
  • Ubuntu 9.04
  • Ucd
  • Uncategorized
  • Universe
  • Ux
  • Vista
  • Wollongong
  • Work
  • Working From Home
  • Xml
Copyright © 2021 Shelter.nu