Reflective Cell-Organism Vision

How cute, check out this screenshot:

At the top is my meebo Instant Messaging application, & at the bottom is my blog, with the Meebo me widget. You can see all blog visitors in the buddy list of the meebo application!

Thanks a lot Meebo!

Finally had a chance to download books from the World eBook Fair , as it was the last chance to do so, this year. Turned out all of the books I downloaded (294) are available all year long (Adelaide collection), & that I already have some 95% of them in hard copy (I browsed the classics). It was a nice feeling to learn that my library contains most of the classic texts of the western culture. It was a strange feeling though to be able to fetch free of charge hundreds of books, from my bed, after spending many years in traversing shelves of book stores, ordering books from the Web & managing a large library of hard copy books.

I only got 300 books, coz my son nagged me every 5 minutes to continue developing with him a computer game (Ninja turtles vs. Sonic) using StarLogo TNG. Such a cool platform for children.

availeble on Flickr, e.g., region 7 & 2:

I hope you find them valuable (useful, usable, findable, credible, accessible & desireable)?

I was thinking on the simplest way to test my emergence engine, & came up with an extremely simple task – the reactive algorithm of a thermostat: measure the temperature, & turn the heating on & off to maintain a given temperature. It sounds indeed very simple to code a program that does that, but what I’m going to experiment is how to do it without any programming.

Emergence engine is a kind of general AI, capable of achieving goals, without being programmed how to solve them. It’s based on the assumption that you don’t need to build real intelligence, rather just create many many simple software workers, having only very simple tools & logic, & let them swarm their way toward the system’s given goals.

So, here’s how I hope my engine will handle the test case:

• It should 1st learn by elicitation the model of a room, having a temperature, thermometer & heating unit.
• It should also learn the relevant beliefs on the effect of using the thermometer on the accuracy of the model, & the effect of turning the heating on & off on the room’s temperature
• It should then learn what’s the desired temperature
• From this it should start deriving action plans & execute activities to achieve the goal of maintaining the desired temperature
• It should also adapt to changes in the room, e.g., a door is open & there’s need to use more heating, or alternatively the heating doesn’t work & we need an alternative heating unit

I’m saying it but of course what’s doing all this are many collaborating agents, working together to achieve the goal. This is done by breaking the value in the goal into smaller value “summs” given to states & activities leading to the goal, & having the agents collaborate on creating all these summs.

Although the design is very simple, & intended for complete autonomous behavior, I noticed that I’ll be able to effect the engine & help it reach its goal, by changing the knowledge driving it, i.e., the learnt beliefs, according to which the agents work.

So, I can’t wait to see how the engine will handle this, which will actually test whether the simple emergence design is enough to yield emergence, even if the value it delivers is so small & simple.

I’ve been using this simple pattern for the past year & a half now, to facilitate SOA, & didn’t yet stop to ponder & evaluate how valuable is it.

KQML stands for Knowledge Querying & Modelling Language, & basically defines a simple message structure, that contains fields like:

• Speech Act
• Recipient
• Sender
• Language
• Content
• Ontology

(there are many more fields, but these are the most important.)

I use KQML together with a distributed shared memory (from GigaSpaces), to create a distributed architecture in which many service providers & applications basically converse with each other in order to achieve almost anything. Any piece of code is devoted to sending & receiving messages, calling services, processing them a bit, & sending them forward.

This allows more complex grid like distribution, using mechanisms that load new service providers according to the accumulation of unhandled messages.

What I learnt using this architecture is that the use of semantic-enabled content (e.g., OWL) made the required message processing much simpler: usually, the content is meaningful to all conversing service providers, so they don’t need to modify it much, just behave according to the requested speech act.

It turned out quite useful & simple for integration with service providers: they usually liked the simplicity of the pattern, requirring them only to know which speech acts are supported & what logical content they need.

Overall, KQML yields quite nice SOA, but it isn’t so common & adopted, because most people turn to well adopted standards (e.g., WS, which can be made semantic using OWL-S). I’m going to start working soon on a new architecture requiring much more dynamic & collaborative conversation, which will put KQML to a real test.