Hmm, it seems that no one has blogged, tweeted or mentioned my blog post in my last plea, which I'm quite disappointed with. However, I'll chalk this one down to the complexity of what I'm trying to accomplish, and my failed attempt at explaining what it is.
In the mean time I've been working at it, converging various models from all sorts of weird places (anything from WebServices and SOAP stacks, to operating systems like Linux, to event models in Java and .Net, to more conceptual stuff in the Semantic Web world), but boy, you can tell that we live in a world shaped by iterative imperative paradigms of approaching the software world.
One thing I learned quite early was declarative and functional programming, introduced to me, of all places, with using XSLT many years ago. It may not be the most obvious place to find it, and this is one of those hidden gems of the language which still doesn't enjoy too much of a following. And no wonder; people come into it from the imperative stuff that dominates the world, polluting us all with filthy thoughts of changing variables (at least in Scala you can choose between var and val), functions that aren't truly functional, and the classical idea in object-oriented programming of a taxonomical structure that doesn't hold up to scrutiny.
Let me clarify that last point. Wht are we doing this stuff? Why are we creating computer programs?
To solve problems. And who are we solving problems for? For humans. It's the classical example (albeit extrapolated) of garbage in, garbage out. I've talked about this in the past a lot, about the constant translation that happens between huna and machine, and how we are creating translation models in both worlds in order to "move forward" and solve problems better. But this excercise becomes increasingly harder as our legacy grows, so trying to teach functional programming to people who don't understand certain basic principles of Lambda Calculus is going to be hard, just like it's hard to teach Topic Maps to people who live in a SQL world. Or like it's hard to teach auto-generating user-interfaces to a user-interface developer.
These are usually called paradigm shifts, where some important part of your existing world is totally changed as you learn some other even more important knowledge. You must shift your thinking from one way to a rather different other. And this is hard. Patterns of knowledge in your brain is maintained by traversing certain paths often, and as such strengthening that path (following the pattern that an often travelled path must be the right path). But if the path is wrong, there's some pretty strong paths you need to unlearn. Damn, that is hard! Which is why I urge you to try it out.
I'm currently using Topic Maps, human behaviour driven ontologies for auto-generating applications and user-interfaces over functional complete models of both virtual and concrete human domains, all with temporality and continous change as the central paradigms. Yeah, pretty hefty stuff, and I've spent years trying to unlearn stuff I learnt in the years before that. And those years were unlearning some other stuff before that. My whole life has been one huge unlearning experience, and I don't think any other way conceptually grasps the beauty of life better; nature and life both are in perpetual change. Needless to say, I'm enjoying every single crazy second of it!
But back to my event model ontology. I've learned one important thing in all this; Sowa has suggested a shift from logical inference to analogy, and this coupled with the OODA loop can create an intriguing platform for knowledge management and eco-system forsoftware applications. I'll let you know more as things progress from here. I'm excited!
And as always, I'd love to hear your comments on all of this. I beg you. Again. :)
No comments:
Post a Comment