caramelleas

Getting sure IT should be 50% working, 50% continuous research

2010-01-03T15:33:00.004+01:00

I'm getting more and more sure IT should be 50% working, 50% continuous research. As for medicine research means fixing more mankind problems, IT research means getting closer to artificial intelligence, not necessary to unviversal computation pourposes, but to solutions from a science that is cross boundaries for all the others.

“...clouds on the left and clocks on the right and animals
and men somewhere in between.”

(K. Popper 1965)

Emergence from systems, of intelligent new features. Evolution hits cells and logic, order, caos at the same time ? Is there a fractal model for all ?

2010-01-03T15:12:00.009+01:00

Emergence showed in "Game of Life"

(from http://www.bitstorm.org/gameoflife/)

(look at it on Google, or on "Feltz - Self-organization and emergence in life sciences, Springer", if you are a rich man) is very strong but there are other mechanisms by which simple rules lead to complex dynamics. The neuron in brain is a simple,
deterministic machine that cannot lie or make an cannot make errors, but emergence ensures that we (the brains) can lie, using and being made of neurons. There is so hope that a more complex "Game of Life" built on structured and meaningful representations of information could evolve from simple rules to self generated and generating complex schemas ? Does it mean that a simple but well generalized "Game of life" could produce new schemas or rules (entities involved and rules moving the entities) able to seem intelligent, NOT BY CREATION, BUT BY ITS OWN EVOLUTION ?

IS INTELLIGENCE SOMETHING THAT CANNOT BE ACTUALLY CREATED, BUT SOMETHING YOU CAN PUT THE BASIS FOR AND WAIT FOR "EVOLUTION" TO CREATE IT FOR YOU ?

From the "Game of life" I saw that new entities and entities' distribution schema appears. Not new rules. Could new rules be self defined like it happens in the above mentioned "Game of life" for entities' distribution schema ?

What if information (CIU) were measurable and numerically comparable ? Composable information units' chains can aggregate in one big chain of chains ?

2009-12-17T23:22:00.010+01:00

When I think to a composable information unit chain, I see that one of the information unit in this chain could be an (x, y, z) position. This is an information made of 3 numbers. if two info units should be compared, this comparison would be numeric, to obtain the closest point, or the fastest. As echoes coming from virtualized sensors and actuators' invocation feedbacks are almost always numeric, so I can try to generalize and say that:

information units could be numerically comparable

here we are, we have now changed the original concept of composable information unit, onto composable comparable information unit

This should allow easier debugging of the units comparison actions' results.

Moreover, there could exist chains of composable information units chains. This would imply that system micro experiences, (micro means for me short in time), could aggregate spontaneously (spontaneously ? Wow..) in more structured and system relevant "experiences".

Chains of composable informaton units chains: spontaneous aggregation of short in time system experiences.

Question: should all composable information unit chains be part of one big overall chain ? Links between chains (and chains of chains) would be like synapsis ?

Social artificial intelligence

2009-10-13T22:35:00.009+02:00

Answer me, you, reader: is social intelligence a design pattern for artificial intelligence ? It is a simple thinking this one coming from me but, looking at human society, it seems a spontaneous association to use rules automatically establised between humans, the simplest among them, to rule animed pieces of abstracted information. it seems sometimes that given a model, to obtain more from that model, you have to put in the model more complexity, or make the model capable of more complexity. I 've been speaking for a while about active pieces of information, "behaving" like bees of a beehive, linking each others to build structured "experiences" as a part of their artificial life, to make a knowledge base. The rules that rule these infomation-bees are the basic rules of a society of individuals. Competition, physiological needs, natural selection, mutations, adherence to enviroment' changing, are the drivers to move a society into non a static group. It makes me smile, that is generally good as a consequence, but it is like to steal honey from the beehive, if we steal the decisions taken by the swarm of composable information units, while this swarm does its best to survive in a virtualized world made by a virtual machine, acting as an hardware abstraction layer to sensors and actuators.

The behavioural engine pattern

2009-10-05T00:30:00.006+02:00

I'd like to outline that I consider the approach of developing a behavioural engine as an intra application integration pattern:

1 to encapsulate the part of the application in charge of defining what the application itself should do in a defined, restricted, non entire application pervasive scope of objects

2 to create as a conseguence of point 1, an interface between the behavioural engine and the auxiliary objects using or being used by the behavioural engine itself. In the economy of the application, these classes not being part of the engine can be grouped up in a so called "shell"

Example of this is Linux: a kernel and a shell to allow the user to invoke kernel functionalities via pre defined paths.

New approach needed: a structured data bag is needed to keep information: compose-able information units can't be that flat as expected

2009-08-30T12:14:00.002+02:00

CIU need to carry the piece of info saying "I was generated because of a sensor reading operation" or "I was generated because of an invokation of an actuator, done with these values and whose result was". It is like driving a stepper motor: you have to read the feedback to understand if the pulse moved something, otherwise information could be useless and corrupt the knowledge base introducing false results.

Fix to data rendering for DTOs that have "setter" methods

2009-08-30T01:53:00.005+02:00

Solution to data rendering for DTOs that have setter methods, could be actually easy. I will try making a call to send a write action notification whenever a "setter" or a "write to actuator" method is invoked (like driveLeft(), driveRight(), brake()). This should bring getters (like getCenterOfMassPosition(), getLinearVelocity()) and setters for data operations on virtualized sensors/actuators, at the same level of abstraction. At this point, this is the situation: virtualized sensors reading actions and virtualized actuators invokation actions can be represented with the same hardware-domain-neutralized objects. All the operations can be represented. Question is: operations need not only to be represented (I just did it hopefully), but also to be performed, of course for the operations of type "write" on actutators. If a "driveLeft()" call operation has been saved as performed, the same operation should be able to be replicated again. This way we are already facing with the needs of the agnostic decision maker working with relations among compose-able information unit.

How to transform a java object, a dto essentially, in a "shape" of the information it keeps

2009-08-26T17:03:00.005+02:00

An object of the type I'm taking into consideration has few things to offer to be manipulated (and this is good): it has "getters" and "setters" methods, plus values kept is class variables accessed by these. Now, what do I mean for shape of an object ? I speak with myself but it is anyway a good question. Shape is the object represantion that can be viewed by an agent that must be able to do operations on these. I'm speaking about a composable information unit produced from a dto of data received by sensors. So, shape has not to change with time passing, and many read operations on the same object must find the same "shape". The conclusion of this analysis is that the shape of a dto is a sorted list of key-value pairs with its getters and setters methods names as key, and values retrieved by the calls to these as... values.

Example: object class "person"

key: value:
getName stefano
getAge 35

This seems to run fine until I don't get into considerations the writable methods: the setters.

Information rendering: from sensors' readings to composable information units

2009-08-26T01:19:00.005+02:00

Code on svn repository is at a very interesting point: I need now to define how to render a DTO java object (the paylod in jmx notifications received by virtualized sensors), into a knowledge domain, how to render them into a composable information unit, removing its original nature of jmx:

package it.free.i.virtual.machine.hal.devicealias.echo;

import it.free.i.virtual.machine.hal.devicealias.command.DeviceAliasPortCommand;
import it.free.i.virtual.machine.hal.devicealias.laboratory.positioningsystem.physics.CenterOfMassPosition;
import it.free.i.virtual.machine.hal.devicealias.laboratory.positioningsystem.physics.LinearVelocity;

/**
* Positioning data DTO impl
* @author stefano
*/
public class PositionEchoImpl extends EchoImpl implements PositionEcho {

private CenterOfMassPosition centerOfMassPosition = null;
private LinearVelocity linearVelocity = null;
private DeviceAliasPortCommand deviceAliasPortCommand = null;

public PositionEchoImpl(){
super();
}

/**
* @return the centerOfMassPosition
*/
public CenterOfMassPosition getCenterOfMassPosition() {
return centerOfMassPosition;
}

/**
* @param centerOfMassPosition the centerOfMassPosition to set
*/
public void setCenterOfMassPosition(CenterOfMassPosition centerOfMassPosition) {
this.centerOfMassPosition = centerOfMassPosition;
}

/**
* @return the linearVelocity
*/
public LinearVelocity getLinearVelocity() {
return linearVelocity;
}

/**
* @param linearVelocity the linearVelocity to set
*/
public void setLinearVelocity(LinearVelocity linearVelocity) {
this.linearVelocity = linearVelocity;
}

/**
* Set the command that caused this response to be generated
* @param deviceAliasPortCommand is the source do read command
*/
public void setInitiaLDeviceAliasPortCommand(DeviceAliasPortCommand deviceAliasPortCommand) {
this.deviceAliasPortCommand = deviceAliasPortCommand;
}

/**
* Get the command that caused this response to be generated
* @return source command that caused the do read operation
*/
public DeviceAliasPortCommand getInitiaLDeviceAliasPortCommand() {
return this.deviceAliasPortCommand;
}

}

In other words: I have some setters and getters and values associated. I think that the name of the method could generally become the name of a property, whose value is obtained invoking that method. Doesn't matter the semantic of the name of the property, they just have not to collide each other or overlap (this approach satisfy this need and make it simple to see original data). Can be that every composable information unit is a bunch of key-value pairs, where the keys are the methods' names and values associated are the values obtained invoking the "keys" ? Of course a dto can have nested objects to render in a flattened representation (no nested objects please), so every dto must provide its rendered version because of the paradigm interface defining what a payload for jmx notifications is.

Where are CICs in relation to the whole system ?

2009-07-13T00:30:00.002+02:00

This schema to explain where are the CICs in relation to where the hardware is and the domain objects associated with the system hardware's components. The CICs objects and the hardware related objects are unbounded: meaning get translated from a domain to the other via a domain neutralizer, behaving like an hardware abstraction layer.

Thoughts

2009-06-22T23:06:00.006+02:00

A group of information (DNA can be an example ?) can be considered as an informaion context ? If information are grouped up for unit of time they were captured in, is that the time context for those information ? It is not of small importance this, has it gives a new light to next steps in theory. How do different context with different meanings interact ? Phrase semantic, a new further view on this new concept (that is composable inormation unit chains HBRWCIC, HBROCIC, HBWOCIC), could help. Every time I find a new view on the elments of the theory, It implies having more opportunities to find a better approach based on a different meaning and analogy/pattern.

A collection of information units makes an experience

2009-06-17T22:00:00.003+02:00

Explaining: a composable information unit is a bunch of data received by a virtual sensor installed on the virtual simulation environment (the car with the simple shape of a box). This info is transformed into a DTO that generalize the concept of information into a "composable information unit" (CIU, CIU can be CIU obtained by a read or write operation: CIU(r), CIU(w) ), neutralizing the specificity. In a unit of time (a clock class capture them) several iformation are received, usually of different type. All the info collected in a unit of time are grouped together to build a so called "experience". Experiences will be all saved to make a knowledge base that will be source-agnostic. We will call this collection a "composable information unit chain": a chain of CIUC. Every CIU and CIUC has a timestamp as a reference on the time axis. So every CIU and CIUC has an age. Let's now think about how to work on the several obtained CIUC.

I'm thinking about introducing "generations" for CIUC as well as for generations for the steps I make refining my theory, producing a new version of it every time.

Requirements for the DTO that should carry data for the ciu

2009-06-02T20:12:00.000+02:00

Going to design the java object for carrying data taken from the jmx notification what should be considered a requirement ?

1 Must be generic enough to be able to absorbe differences between different types of notifications into a common interface.

2 Could be needed to be thread safe, like a non mutable object.

3 Its properties must be able to be explored by external agents (that could be one or more threads, see point 2).

4 Could be needed to be link-able or group-able with other composable info units.

From virtual devices' echoes to composable information units

2009-06-02T18:45:00.002+02:00

About the first point let's analize how to render a composable information unit. These need to change domain as the
format they have when they are received by the clock class (DeviceAliasPortReadClockDaemon) is still very jmx-
notification like. In a very simplified view every information received is a property (sometimes structured) object.
Thinking to this (I ilike this game of watching objects as physical shapes) as geometric elements, what is that is
defined by a variable eguals to a number, another variable equals to another number, like:
x = 1y = 3z = 5anothervariable = 7stillanothervariable = 12
It seems to me to be a point. A point in a space defined by as many dimensions as how many are the properties
carried by the composable information unit received. So, for example, let's analize a sample (one unsolicited echo
received because of the fuel limit notification, an interrupt driven echo received because the vehicle bumped
against an obstaclea, an echo sent back as an answer to a read request generated by the clock class to gather the
vehicle position):

Sample of fuel notification that says "GREEN" level: ****************************Sequence number: 4Source: FuelTimestamp: 1243956311584User data: User data payload: it.free.i.virtual.machine.hal.devicealias.echo.DynamicParameterChangingEchoImpl@7ec028Dynamic parameter changing echo parameter name: FuelDynamic parameter changing echo parameter level: GREENUser data payload data type: nullClass: class javax.management.NotificationMessage: Fuel FuelType: UNSOLICITED_VALUE_CHANGED****************************

Sample of a collision detected echo:
****************************Sequence number: 21Source: devicealias.port.positioningsystem.collisiondetector-1243956298973Timestamp: 1243956311506User data: User data payload: it.free.i.virtual.machine.hal.devicealias.echo.CollisionEchoImpl@191777eCollision echo impacted object type: 0Collision echo center of mass position: x: 1.8370745 y: -3.553998 z: 1.1854142Collision echo impacted object description: BoxUser data payload data type: nullClass: class javax.management.NotificationMessage: devicealias.port.positioningsystem.collisiondetector-1243956298973
devicealias.port.positioningsystem.collisiondetector-1243956298973Type: PORT_INTERRUPT****************************

Sample of an echo received by the on board virtual GPS:
****************************Sequence number: 8Source: devicealias.port.positioningsystem.locator-1243956300864 READ verb answer Timestamp: 1243956312178User data: User data payload: it.free.i.virtual.machine.hal.devicealias.echo.PositionEchoImpl@10e18baPosition echo center of mass position: x: -0.022259876 y: -4.7243595 z: -0.15895882Position echo linear velocity: Vx: 0.011706882 Vy: 0.16265121 Vz: -0.14992155User data payload data type: nullClass: class javax.management.NotificationMessage: devicealias.port.positioningsystem.locator-1243956300864 devicealias.port.positioningsystem.locator-
1243956300864 READ verb answer Type: PORT_DO_READ_ANSWER****************************

These logs come from the application running a test. Now, these three types of echo you can find in package
it.free.i.virtual.machine.hal.devicealias.echo, are always communicating a bunch of information (as seen, solicited,
unsolicited, interrupts) but they have heterogeneous formats, as some have a structure, some have different
properties. This implies that a neutralizer and a common format is needed. possibly the format will be made as a
property object representing so an n-dimensional point in a n-dimensional space. This sounds particularly
interesting if taking into account that these will all become what we defined as composable information units. From
a geometric perspective these will be points going to be linked together and, still to play with solid
representations for java objects in design, these points linked in a structure will create a sort of "segment" or a
solid volume. Important to note: different points derived from different composable information unit could have a
different number of properties: points with different number of coordinates, so points in spaces with different
numbers of dimensions. The reason why I continue with this parallelism between java objects and geometric shapes is
that the closer I get to the "experience store" (knowledge base) representation, more It seems that the aggregation
is something more easy to understand if it is "visible". Well, it is also funny.
First problem by now, important to be solved, is the definition of a DTO for the composable information unit, and
(this comes for second and it is simpler to me) of a renderer to change every echo object into a unit of generalized
information.

swarm-i code evolutions

2009-06-02T02:24:00.003+02:00

Code in warm-i is now at this point: a simple vehicle using jbullet demo has been instrumented using jmx. This allow for virtual device aliases (plugged on the jbullet demo) to collect informations and push them into a "clock" that every "n" milliseconds set on configuration, group up these data bags received from different virtual sensors into snapshots of the system. These informations received have attributes. These are composable information units. There are interrupt generated values for collisions, a positioning system, dynamic parameter fluctuating as fuel and structural consistency. These decrease with time but could be increased when hitting a specific shape. Commands are also available to: brake, accelerate, turn right and left. These will be made available to the clock thread as well. Now problem will be two:

First: how to render these data (as specified before all are echoes from read input commands sent by the clock class, or unsolicited interrupt-like jmx notifications) into composable information units. These are already collected in bundles grouping them toghether for the unit of time they took place.

Second: interesting game, defining how to create relationsships to build composable information units' chains.

It is necessary to solve first point 1.

Second: how to start

Answer is not a secret

2009-01-20T00:03:00.002+01:00

As staten before, answer to that question is in:

http://en.wikipedia.org/wiki/Natural_Select

This can be applied to a swarm of composable information unit population ? Ok, but so linking between units, as they are composable, how does it much with natural selection algorithm ?

Problem is here again: two main features:

composable
natural selection population

Is one of these two wrong ?

"Rational" of the swarm common consciousness

2009-01-19T21:29:00.002+01:00

At http://en.wikipedia.org/wiki/Natural_Select I can read about natural selection rules, and it is clear that looking for a rational cause for the swarm consciousness, it is possible to find that most of the units composing the swarm will act in a certain way. This will build "the trend" in the swarm behaviour. Now, let's change the previous question into this one: why most of the units act in that correct way that is positive in the balance of the swarm, whose intent is to survive and perfect the life of the swarm itself ? Why most of the units behave in "that" way ? Back to the unit, is it unit that somehow choose how to behave, as most of them choose in the correct way, how does it choose ?

Natural selection of better software units in the composable information unit theory

2009-01-18T23:46:00.005+01:00

It is not so common to have to think to natural selection theory, if you are not in the traffic. Yes. It is not something complex but interesting for me, so I take note to avoid to forget, here in my composable information studying journal. In a community the weakest unit dies to allow the community to have more change to survive (the community makes it die). The selection is performed by the swarm itself, like to say that the swarm makes choices. Swarm makes choices ? So swarm has conscience ? I correct: so the swarm has an its own intelligence ? Who gaves it to the swarm ? If no one gaves to the swarm any intelligence, is this a sort of side effect of the single intelligences of the units that compose the group ? There is a trend so of all the units to go in a "direction", in that way instead of a different one ? Moreover, according to natural selection the weakest units are selected to be abandoned because not productive for the whole swarm ? So the swarm knows which unit is weak, and so knows about every unit ? It really seems to me that the swarm projects over itself a super entity that is an emanation of all the units. This is like the behaviour of all the units creates its own GOD in a trend put in place by the fact that every unit main intent is to preserve its life, this through the existence of the species it belongs to.
I see incredible scenarios about the possible social aspects of the natural selection theory applied to the composable information units, swarm computing theory derivation. is the super entity the result of driving chaos of units ' behaviour behind the common and single unit intent of survival ? What can produce a swarm of much more complex entities (for example units having social and ethic rules) when projecting the common super entity that will performe the natural selection of strongests units ? Yes this is already part of genetic programming, but what happens if the code tries to distil the creation of a swarm conscience in the context of the composable information unit theory ? The intent in this context so, is to use this collateral derived intelligence to drive the system equipped with this software. I need to go to read about natural selection and Darwin, topics like random mutations created by "nature" to produce better units.

A particular learning curve: using inouts and outputs being unaware of what they are intended for

2009-01-05T22:39:00.007+01:00

Let's play a game: a person is closed in an cockpit of an unknown vehicle type with no labels on leds and no labels on displays, no labels either on buttons and control levers. The person there inside can only see that when values changes on displays and leds turn on/off, "good" or bad "things" happen. The person in the cockpit has not a driving expertise for the misterious vehicle it is in, but starts associating things to do and values to keep under controls with the correct things to do to keep the vehicle running, preserving the vehicle. Maybe the driver will not associate the correct meaning to each display or button. Simply, the driver cans drive the vehicle without being aware of what controls are but just associating commands with useful or useless conseguences. This seems important, the driver associate values read and commands given on buttons and levers, the first with the second each other creating commands/value read associations in "paths" refined with experience. More experience will lead the driver to create "named paths", so specific path to allow the driver to do "macro" operations on the vehicle. More macros combined together gives "higher" macros. Here there is a new result: until the driver learns all the paths (combinations of controls usage and values to read from displays) the diver has an important learning curve that is essential. It is a sort of consciousness raising the driver has, without it the driver will lead the vehicle to crash somewhere.
What happens if the vehicle is compared to the a software application, displays and leds are vitual input devices, buttons and levers are virtual output devices ? Now new elements are needed to actually compare the system and the driver of the misterious vehicle:

1 The concepts of "good" and "bad" = "advantageous" and "disadvantageous" for the systems, rules
2 Rules to associate "advantageous" and "disadvantageous" with display reads and buttons/levers activations
3 Rules for associating reads and commands activations together in "paths"
4 Rules to update the paths refining them with increasing system eperience, improve the associations

We fall again in the concept of composable info unit but, this time, there are big news: system can absorbe the controls available to the system, without the need to define what displays and buttons to push are. There is an initial learning curve to transforme an unaware system into an aware one. Aware of unnamed inputs and actuators.

A program is as a car, can I think first to what car could be according to program features ? (FR, NFR)

2008-11-30T03:28:00.009+01:00

It happens often that working on a piece of code, its design has to be resilient to stress, fast, flexible to react to changes, able to change the environment where it lives. What else ? Need to resist in time for its lifecicle. Well, enumerating these way the needs for a program it seems to be speaking about an iron made structure fully physical, 3D, with its own materials, like a car. It must be fast, resilient, resistent, enduring, reactive to stress and strain being elastic and so able to return to its previous shape without permament modifications or fractures. They seem the same, isn't it ?

Is it possible, this is my question, to use the inverse procedure, so starting from the model of thinking a software architecture to proceed then starting to think to design ? Choosing a model prototype more suitable to the features the design will have to have, first then starting the design itself can actually help the design phase ?

Can be:

NON functional requirements --> real world physical structure satisfying the requirements (like prototype) --> design ?

This could be applied I suppose just to very high level non functional requirements that state HOW the system should behave and at the same time, they are responsible for deciding actually the architecture design.

Design first, design archetype first ?

Cooperative intelligence, cooperative knowledge and social abstractions of swarm patterns

2008-09-02T23:00:00.006+02:00

Crossing by car a street, coming back home yesterday, I went through a crossroads with a lot of glass pieces on the floor. Terrible to say, but a lot of cars almost every month crash there one with another, with the usual common problems. Obviously it is a problem for the traffic department, as that crossroads is error prone for humans driving vehicles. Going there driving, I was thinking to a new post here, and suddenly a strange idea came to my mind. Every driver that crashed his car there, now KNOWS that there there is a particular situation to take into account, and also who saw the crash happening knows and and is aware of this. Now... all the drivers that for a reason or another had the crash experience will obviously have the benefit of avoiding it. The remain of the drivers will potentially be subdued to the same risk. What's the difference ? Simple of course: the difference is in having the experience for that crossroads or not. Let's imagine now that some experience could be shared by drivers suddenly, in a sort of common knowledge base, populated by everyone and accesible to everyone. Let's say this would be a sort of Big Internet, based on drivers' personal experiences, using a knowledge base produced by the community of this knowledge contributors. Different type of experience, different knowledge context: cooperative shared knowledge. This fantastic landscape really seems a social abstraction of a swarm computing model. Moreover, let's think to the world wide web. May we consider that the WWW is just the first manifestation of a need for a real documentary social knowledge base, made feasible by technology ? What about the so called internet "social networking" ? Again, are humans "swarm-ing" their behaviour at least for information sources ? This would imply thar swarm approach is not unknown to humans as well, and that maybe it could be a relevant role in the "rotism" that build human social intelligence and knowledge.

Correct.: intelligence and knowledge, what is the relationship between these two "pivots" ? What's the interaction among swarm model, knowledge, intelligence ?

Introducing parameters' factory and registry support

2008-08-13T18:05:00.002+02:00

Introducing support classes to create objects, register dynamic parameters:

public class Test extends Observable implements Observer{
public void
init(){
long hearBeatYeldPause = 1000;
long heartBeatsNumber =
100;
String parameterName = "fuel";
DynamicParameter
dynamicParameterDecresingImpl = null;
try{
dynamicParameterDecresingImpl =
DynamicParameterFactory.createObject(DynamicParameterAlgorithms.DECREASING,
heartBeatsNumber,
hearBeatYeldPause,
"fuel",
this);
DynamicParameterRegistry.getInstance().setParameter(parameterName,
dynamicParameterDecresingImpl);
DynamicParameterRegistry.getInstance().registerOnParameter(parameterName,
this);
DynamicParameterRegistry.getInstance().daemonizeParameter(parameterName);
}catch(SimulationLaboratoryGeneralException
slgExc){
slgExc.printStackTrace();
}
try{
Thread.sleep(110000);
}catch(InterruptedException
e){
e.printStackTrace();
}
for(int i =0; i < 102;
i++){
try{
super.setChanged();
super.notifyObservers();
Thread.sleep(hearBeatYeldPause/2);
}catch(InterruptedException
e){
e.printStackTrace();
}
}
}
/**
* @param
args
*/
public static void main(String[] args) {
Test test = new
Test();
test.init();
}
@Override
public void update(Observable
observable, Object arg1) {
System.out.println("UPDATE RECEIVED by " +
observable.toString() + "");
}
}

Associating objects in the virtualization lab, with effects on the simulation vehicle

2008-08-12T19:58:00.005+02:00

Let's state on my game journal that:

Boxes (square boxes, but by now these are the only present) are OBSTACLES

Capsules are FUEL REFILLS

Spheres... hmmm... could be "unknown effect", to impact to check ? Dunno yet. Let's wait they are needed.

How fuel changes

2008-08-11T23:19:00.004+02:00

Fuel decreasing sample starts to run:

Fuel tank collisions, refuelling sample:

Fuel is blinking RED sample:

Links (some in Italian)

2008-08-11T22:59:00.003+02:00

Links:

http://blog.cartaematita.com/temperamente/2008/02/come-api-al-miele-la-teoria-de.htm

http://www.swarm.org/index.php/Main_Page

http://it.wikipedia.org/wiki/Intelligenza_collettiva

Why dynamic parameters ?

2008-08-11T21:07:00.002+02:00

It is correct to explain.

A thread running an algorithm to change a value can be whatever in the context of a mechanical (only ?) system simulation. It is feasible to imagine fuel, decreasing, in a "threaded" autonomous way, while time passes, with a define model of variation. With the code done, and the interface foreseeing the capability to receive a "set" of the parameter name (that's the parameter nature of course, eg: fuel), it can be reused. The observer/observable double mutual pattern, collision with fuel tanks can be notified to the parameter thread, and fuel increased. Thus establishing a relation between the value, changing by itself, and what happens in the virtual environment. Every new parameter, with its own meaning add more virtual devices and multiplicity to the simulation scenario, increasing the number of data types.

A virtual parameter with a thread in its soul, to simulate a new range of virtual sensors, based on the changing of a value, like fuel

2008-08-11T19:54:00.004+02:00

It is intersting actually, two observer/observable patterns, one against the other, to monitor the ongoing value of a ... value ! That simply thanks to a thread and to the common pattern of the earth beat, to decrease or increase with the time, in its own process, with different color levels, a named floating value. This could be fule, for example, or engine oil. It is self sufficient, not needing nothjing more than jdk runtime, and it is so easy that the few classes involved in this game are posted here to let playing everyone who likes:

Parameters threshold for colors:
it.free.i.virtual.machine.hal.devicealias.laboratory.simulator.dynamicparameter.Levels

DynamicParameter factory (actually only the DEcreasing impl is available):
it.free.i.virtual.machine.hal.devicealias.laboratory.simulator.dynamicparameter.
DynamicParameterFactory

Paradigm interface for this entity:
it.free.i.virtual.machine.hal.devicealias.laboratory.simulator.dynamicparameter.
DynamicParameter

The decreasing (and the only written up to now) impl:
it.free.i.virtual.machine.hal.devicealias.laboratory.simulator.dynamicparameter.
DynamicParameterDecreasingImpl

To try just use these lines of test class:

import java.util.Observable;
import java.util.Observer;
import it.free.i.virtual.machine.hal.devicealias.laboratory.simulator.dynamicparameter.*;

public class Prova extends Observable implements Observer{
public Prova(){
init();
}
private void init(){
long hearBeatYeldPause = 1000;
DynamicParameter dynamicParameterDecresingImpl = new DynamicParameterDecreasingImpl(this);
dynamicParameterDecresingImpl.setHeartBeat(100, hearBeatYeldPause);
dynamicParameterDecresingImpl.setParameterName("Fuel");
super.addObserver(dynamicParameterDecresingImpl);
Thread daemonThread = new Thread(dynamicParameterDecresingImpl);
daemonThread.start();
try {
Thread.sleep(110000);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
for(int i =0; i < 102; i++){
try{
super.setChanged();
super.notifyObservers();
Thread.sleep(hearBeatYeldPause/2);
} catch (InterruptedException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
/**
* @param args
*/
public static void main(String[] args) {
Prova prova = new Prova();
}
@Override
public void update(Observable observable, Object arg1) {
System.out.println("UPDATE RECEIVED by " + observable.toString() + "");
}
}

Composable information unit 3D shape definition goes through single dimension abstraction definition

2008-07-07T22:31:00.003+02:00

Let's assume code in Google is ready to produce informations to be transformed into a new java object, standardized for the application domain of the decision maker, via some interfaces ad hoc defined. These infos will be de-boxed and re-boxed into what has been previously defined compose-able information units. It is important to create a spatial 3D concetual shapes for the compose-able information units. This means that these units will be shapes, whose shape changes accordingly to their data content. Let's say a pojo whose value is an integer whose value is 3, will be a box, a pojo whose value is an integer whose value is 5 will be a sphere. This is very simplified, but could help in understanding as it really seems to me that human brain is more confident in approaching spatial problems. So: for this conceptual 3D shapes, how could be defined in term of software data representation, a single DIMENSION ? Every compose-able information unit will be threaded to become a virtual swarm belonging bee, able to link other bees. The behaviour of this swarm wil be translated into a system "expert" behaviour.

Last built hardware testing platform

2008-07-07T21:37:00.005+02:00

These are some few shots of the hardware assembled to perform tests for a previous design of the same system. Motherboard is a pcm4823 by Advantech (c). CCD, frame grabbers, bump sensors, inclination sensors, two big legs.

side view

front view

legs not mounted on body: front view

legs not mounted on body: side view

rear view

Linux debian is on board, installed is also a GSM modem but it is not used yet. To provide minimum perimeter penetration events' notifications, there are Sharp GPD2D12 infrared barriers. Legs, when the system is used, are connected to the body one, per side. The motherboard (a POS like one) based on the industrial PC104 standard, for high level computation. Another board uquipped with a Motorola 68HC11 performs the readings from all sensors, makes all writing on all actuators. This board is quipped with a customized jvm created for this type of device. This board by Grifo implements the "man in the middle" design pattern.
It is possible to see details about the board and the java runtime at http://www.rtjcom.com/6811/gpc114.html. The motherboard is instead visible, here: http://taiwan.advantech.com.tw/support/sr_detail.asp?SR_ID=1%2BGE%2B1057. The problem is always the same, buy hardware after you know exactly the software requirements. Also when hardware is very interesting and an excuse is needed to have it, just because it has on board a 16MB disk on chip storage (DOC2000). A note on the "vision" system: the CCD was mounted inside a thermal insulation provided box with a Peltier cell just behind the bottom of the camera box. This because the intent was to keep cold the CCD and perceive infra red frequecies in few enlightened environments, making a bigger difference between the internal camera box temperature and the external world temperature. Simple pattern recognition was performed using PNG image files captured by a digital parallel port converter, connected to the analogue camera output.

This prototype name was "virgola", "comma" in English

(Every trademark is of its own properietary)

Title for the previous post

2008-07-03T23:43:00.003+02:00

Name for the previous taken note on my game journal:

Intelligence extraction and internal to external driven mutation, in a vitualized swarm equipped system.

About the importance of social relationship between virtual swarm entities, in the economy of the intelligence extraction from whole swarm behaviour

2008-07-03T22:55:00.007+02:00

What I'm asking to myself is what happens manipulating the social relations between virtual swarm entities. First it is important to recall that the virtual swarm is a swarm computing like pattern implementation, where the swarm is made up of software agents (for this reason it is called virtual). The behaviour of the whole swarm is captured as "intelligent" behaviour of the system equipped with this implementation. I find this extremely interesting. Code on google is not yet ready to receive such elegant manipulation so, by now, this is just a note taken not to forget the idea. Assuming that it could be possible to change the flavour of social relation manipulations, these could be a lot. Some samples that come to my mind just on the fly go from the "basic instincts" level to "ethic" and more noble instincts of cooperation established for a social common intent between the entities being part of the virtual swarm. It is easy to note that more evolved schemas have as a main intent the safeguard, the protection, not of the sigle entity, but of the whole swarm, or social community. Very interesting, evolving social behaviours the virtual swarm changes into a social community. Evolving the level of relations inside the virtual swarm, it is not only cause of a mutation of social intents, but maybe can cause also the mutation of the swarm itself nature. A swarm is just a group without social conscience or perception of itself, but can mutate into a social group of evolved entities. From a virtual swarm to a social group, in a driven evolutive mutation. Question: how mill mutate in consequence of internal mutations, the intelligent behaviour extracted from the system ? Will mutation in the"virtual swarm brain" be propagated to the "virtual swarm brain" equipped system, and how ?

Collision detection

2008-06-11T00:04:00.003+02:00

Reading and analizing ConcaveDemo, still from jbullet:

I changed the vehicle demo adding a callback for the collision. For sure collisions detected by the jbullet API layer, will have to cause an unsolicited message post from the virtual sensor port to the decision maker layer, inside the system. Position is instead read on demand with solicited port read commands, from the system decision maker to the virtual sensor port.

I'm using jbullet from http://jbullet.advel.cz/

2008-06-10T23:45:00.005+02:00

I'm using jbullet with some simple modifications in order to create a test world to link virtual sensors to the swarm-i system. The idea is to let swarm-i read from the VehicleDemo as it was reading from real sensors, and let the same swarm-i system drive the vehicle of the VehicleDemo sample. I added some more shapes like sphere and capsules, in order to associate some shapes with obstacles, some others with "things to search for", some others with dangers (capsules for example).

So, what could be better than a simulation API for physics ? It also allows a wireframe view in order to see relative reference system:

Components provided by device, device alias implementations

2008-05-08T00:21:00.004+02:00

Details: from HAL to inof units device independent data representation

2008-05-05T00:02:00.003+02:00

A question about intelligence models

2008-05-04T20:20:00.006+02:00

If

intelligence is the way of solving propblems using the best patterns, is intelligence itself a pattern to analyze and solve problems ? This doesn't want to appear as a pun, but, if this is true, so intelligence could be "taught" like every other "mechanism", design the mechanism and intelligence will not be anymore something special. Yes, we are still in the artificial intelligence toys context, and this is still a game, but this is maybe what is happening when trying to design an intelligent system: the draftsman copy its algorithm, or the algorithm he thinks to be intelligence, inside the system object of the design phase he is facing with. Does this mean that the only possible "intelligence model" is the human one ? So success in producing a non linear (that for me it means somehow intelligent) algorithm is "just" producing the most possible human-like one. What a pity, it could be so interesting to face with a model of intelligence, that is completely unknown.

Simple class from jbullet modified just for a quick and dirty feasibility test.

2008-04-08T01:12:00.005+02:00

Code following has been decompiled from the JBullet basic demo class, changed to have one cube, and trace of linear velocity as well as x, y ,z coordinates of the box. Numbers are from a stupid System.out.println(), then this GUI wil lbe integrated in swarm-i to send these numbers to Lab connected dummy devices. In a correct way.

// Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3)
// Source File Name: Basic2Demo.java

package javabullet.demos.basic;

import java.util.ArrayList;
import java.util.List;
import javabullet.collision.broadphase.BroadphaseInterface;
import javabullet.collision.broadphase.SimpleBroadphase;
import javabullet.collision.dispatch.CollisionDispatcher;
import javabullet.collision.dispatch.DefaultCollisionConfiguration;
import javabullet.collision.shapes.*;
import javabullet.demos.opengl.*;
import javabullet.dynamics.*;
import javabullet.dynamics.constraintsolver.ConstraintSolver;
import javabullet.dynamics.constraintsolver.SequentialImpulseConstraintSolver;
import javabullet.linearmath.*;

import javax.vecmath.Vector3f;
import org.lwjgl.LWJGLException;

public class Basic2Demo extends DemoApplication
{

RigidBody body2 = null;

private static final int MAX_SHAPE_SIZE = 1;

public Basic2Demo(IGL gl)
{
super(gl);
collisionShapes = new ArrayList();
}

public void clientMoveAndDisplay()
{

gl.glClear(16640);

if(body2 != null){
System.out.println("# box: x=" + body2.getCenterOfMassPosition().x + " y=" + body2.getCenterOfMassPosition().y + " z=" + body2.getCenterOfMassPosition().z + " linear velocity=" + body2.getLinearVelocity());
}

float ms = clock.getTimeMicroseconds();
clock.reset();
if(dynamicsWorld != null)
{
dynamicsWorld.stepSimulation(ms / 1000000F);
dynamicsWorld.debugDrawWorld();
}

renderme();

}

public void displayCallback()
{
gl.glClear(16640);
renderme();
if(dynamicsWorld != null)
dynamicsWorld.debugDrawWorld();
}

public void initPhysics()
{
setCameraDistance(30F);
collisionConfiguration = new DefaultCollisionConfiguration();
dispatcher = new CollisionDispatcher(collisionConfiguration);
//Vector3f worldAabbMin = new Vector3f(-10000F, -10000F, -10000F);
//Vector3f worldAabbMax = new Vector3f(10000F, 10000F, 10000F);
overlappingPairCache = new SimpleBroadphase(1149);
SequentialImpulseConstraintSolver sol = new SequentialImpulseConstraintSolver();
solver = sol;
dynamicsWorld = new DiscreteDynamicsWorld(dispatcher, overlappingPairCache, solver, collisionConfiguration);
dynamicsWorld.setGravity(new Vector3f(0.0F, -10F, 0.0F));
CollisionShape groundShape = new StaticPlaneShape(new Vector3f(0.0F, 1.0F, 0.0F), 50F);
collisionShapes.add(0,groundShape);
Transform groundTransform = new Transform();
groundTransform.setIdentity();
groundTransform.origin.set(0.0F, -56F, 0.0F);
float mass = 0.0F;
boolean isDynamic = mass != 0.0F;
Vector3f localInertia = new Vector3f(0.0F, 0.0F, 0.0F);
if(isDynamic)
groundShape.calculateLocalInertia(mass, localInertia);
DefaultMotionState myMotionState = new DefaultMotionState(groundTransform);
RigidBodyConstructionInfo rbInfo = new RigidBodyConstructionInfo(mass, myMotionState, groundShape, localInertia);
RigidBody body = new RigidBody(rbInfo);
dynamicsWorld.addRigidBody(body);
CollisionShape colShape = new BoxShape(new Vector3f(1.0F, 1.0F, 1.0F));
//CollisionShape colShape = new SphereShape(30F);
//CollisionShape colShape = new CylinderShape(new Vector3f(1.0F, 1.0F, 1.0F));
collisionShapes.add(1,colShape);
Transform startTransform = new Transform();
startTransform.setIdentity();
float mass2 = 1.0F;
boolean isDynamic2 = mass2 != 0.0F;
Vector3f localInertia2 = new Vector3f(0.0F, 0.0F, 0.0F);
if(isDynamic)
colShape.calculateLocalInertia(mass2, localInertia2);
float start_x = -7F;
float start_y = -5F;
float start_z = -5F;
for(int k = 0; k <>
{
for(int i = 0; i <>
{
for(int j = 0; j <>
{
startTransform.origin.set(2.0F * (float)i + start_x, 2.0F * (float)k + start_y, 2.0F * (float)j + start_z);
DefaultMotionState myMotionState2 = new DefaultMotionState(startTransform);
RigidBodyConstructionInfo rbInf2 = new RigidBodyConstructionInfo(mass2, myMotionState2, colShape, localInertia2);
body2 = new RigidBody(rbInf2);
dynamicsWorld.addRigidBody(body2);
}

}

}

clientResetScene();
}

public static void main(String args[])
throws LWJGLException
{
Basic2Demo ccdDemo = new Basic2Demo(LWJGL.getGL());
ccdDemo.initPhysics();
ccdDemo.getDynamicsWorld().setDebugDrawer(new GLDebugDrawer(LWJGL.getGL()));
LWJGL.main(args, 800, 600, "Bullet Physics Demo. http://bullet.sf.net", ccdDemo);

}

private static final int ARRAY_SIZE_X = 5;
private static final int ARRAY_SIZE_Y = 5;
private static final int ARRAY_SIZE_Z = 5;
private static final int MAX_PROXIES = 1149;
private static final int START_POS_X = -5;
private static final int START_POS_Y = -5;
private static final int START_POS_Z = -3;
private List collisionShapes;
private BroadphaseInterface overlappingPairCache;
private CollisionDispatcher dispatcher;
private ConstraintSolver solver;
private DefaultCollisionConfiguration collisionConfiguration;
}

OK HORRIBLE NIGHTLY BUILT FIX but doing so, Doc Mud has his numbers in the meanwhile:

numbers are like these:

# box: x=-5.2613173 y=-5.000006 z=-5.6992044 linear velocity=(7.113341, 2.5081635E-4, -1.8705462)

# box: x=-5.1365914 y=-5.0000033 z=-5.7320027 linear velocity=(7.483558, 1.6021729E-4, -1.9678993)

# box: x=-5.0183263 y=-5.0000024 z=-5.7619495 linear velocity=(7.095896, 6.771088E-5, -1.7968078)

# box: x=-4.905269 y=-5.0000014 z=-5.78896 linear velocity=(6.783436, 6.9618225E-5, -1.6206144)

# box: x=-4.726717 y=-5.211472 z=-5.7739735 linear velocity=(10.713142, -12.6882305, 0.8991995)

# box: x=-4.6235833 y=-5.126884 z=-5.765317 linear velocity=(6.1880307, 5.0752907, 0.5193877)

# box: x=-4.511769 y=-5.0761304 z=-5.755932 linear velocity=(6.7088833, 3.04521, 0.5631053)

# box: x=-4.3964 y=-5.045679 z=-5.7462482 linear velocity=(6.9221334, 1.8270884, 0.5810045)

This is an easy, funny fast way to produce numbers to infer with a new intelligent prototype for the swarm-i hig level logic.

Graphical generation of test data for the system

2008-04-06T20:51:00.004+02:00

Doc Mud (thanks for the link to the great jbullet toy: http://jbullet.advel.cz/),

to gnerate test numbers to let you play with high level (this.)system intelligence design, can we use povray ? No, he suggested blender3d and jbullet. This to allow us to use a physic simulation library, to go through a software design of the sample. The sample will run producing the numbers for the tests. Result should be: we will design the cube and add its physic features, for example a cube falling down, then capture the numbers we need. Ah ? :)

I dunno yet if it is feasibile (too night to test it now and tomorrow it is another bloody monday), but doing so, while you move your cube here running in the same jvm of the "system", postion of the cube is sent to the dummy devices (in real) time, these will post back to the virtual world values read, and transform what you do here on the guy, into composable information units !! Then it will be possible to apply different algorithm to collate composable information unit and have some experiment scenarios. Good lab to play.

PS: on http://jbullet.advel.cz/ try to run the demos. They are very interesting.

Data samples to infer high level abstraction logic ?

2008-03-30T22:44:00.005+02:00

Doc Mud, that is a great reader of intelligence design patterns (neural networks, expert systems... this, that...) asked me for some data samples to test one of his ideas. My first answer was: as we have now the first level of hardware abstraction, let's use the written part of system to get data, using the dummy devices added in the "lab" subpackage. Well, I tried and I found a reason to smile. Nature, physic, has its logic, it is like if it has a rule to produce numbers according to hidden perfect rules, able to take into consideration all the aspects. In order to have the system producing data samples that are valid for any game (DocMud one is this today) the data must have a rule behind (dummy devices should contain this logic), just like nature likes to do. Now, or I try to calculate some numbers using a principle every time, simple one, to give data to DocMud (for example some numbers that are coordinates belonging to a geometric place) or I can put a number generator inside the system, that allow to generate numbers every time, different numbers, but always having a sense behind, changing the rule. The sense is the rule (all numbers are coordinates in a bidimensional space for example). In this way it could be possible to use the system to read data generated by the dummy devices. Dummy devices will have to generate numbers with a rule (the coordinates) defined by a virtual space, that has constraints and principles like physic has in the real world. Of course in this virtual space abstractor, rules will be very simple and possible to be changed. This could be a part of the laboratory.

Example: with the virtual space simulation it should be possible to define a cube, or a face of a cube, and ask for some coordinates that fit the rule to belong from the cube surface, or from one cube surface, or... or...

This could complete the lab environment.

Doc Mud, your opinion please :)

Boxing infos and what will be "swarm-ed"

2008-03-24T21:40:00.004+01:00

Propostions and review:

what about if the unit of the swarm is a behaviour of the system at a "t" instant ? What is a system behaviour ? A system behaviour is the collections of all the input and output performed by the system at that "t" time. Swarming should help in deciding what behaviours can be associated togheter to bring system to success. What is system success ? System success is bigger when the system is closer to the fullfillment of its needs. How could we define needs ? They are just simple master-rules or "perfect pre built" behavioural "trends" for the system itself. Now for the code is time to go versus data boxing, to bring to the upper logic subsystem the information to compute in a non linear way.

Info unit flattening eterogeneity and incapsulated specificity ?

2008-03-15T23:44:00.004+01:00

Is it a good idea to flat the complexity of different sources (device aliasese and device alias ports) generated info units, to the common paradigm of a single representation model ? Some info unit could hide incapsulated complexity:

a camera sensor could produce numbers, as pixels, or the whole image could be an info unit. In this case the info unit could be for example the context, the meaning of the whole image, and pixels as info units (1 pxel as 1 inof unit) could be useless. This is what I mean when I use the term of "incapsulated complexity".

New implementation diagrams

2008-03-15T21:26:00.001+01:00

Jconsole view of the jmx implementation

Activity digramClass diagram

Collaboration diagram

Component diagram

Recap and status update

2008-03-14T23:50:00.000+01:00

Up to now a small result is the comprehension of the path followed to performe the first analysis part: it is small income but interesting.

First: define the distance between reality and the intelligence that have to understand reality

Second: provide abstraction for the level of complexity the system will digest

Third: design the "gnoseologia", whose translation in English I don't know, I'm sorry

Fourth: define subsystems, the low level layers abstracting the world or delivering infos to the intelligence upper-subsystem is essential and must be suitable for the target of the project in terms of functionalities and non functional features.

Note: system design try normalize data received by hardware abstracted, acting also like a normalized message router. This because common units can be manipulated when they are all flatted down to the same type of object (for the code, it will be the same interface).

Status of coding: as suggested by doc mud, the two observer/observable patterns have been replaced by a jmx implementation. Parts missing are:

From the virtual device alias ports, data must be rendered as generalized abstracted information units.

The intelligent agent, that will act like the class provided for this pourpose in order to have a sample: it.free.i.virtual.machine.hal.devicealias.laboratory.DocMudImpersonatorWorker

LDAP as a jndi provider: this allow an easy view and management of configuration , in a centralized way. Easy to view, easy to understand

2008-03-02T21:17:00.000+01:00

I'm going to post now two views of the jndi repository tree, keeping the software identities being part of the system hardware abstraction layer. Code on the google site is now mature up to this.

UML diagram of the hardware abstraction layer, up to now and nightly built

2008-03-02T01:39:00.000+01:00

Uml for the hal subsystem

Structural patterns while taking a decision about the info unit chains computational model

2008-02-29T13:16:00.000+01:00

New hypothesis

2008-02-25T21:40:00.000+01:00

Doc Mud,

this peripatetic way to approach a discussion about a theory, is easy and allow to fix ideas before they go away. Listen to this approach.

Let's assume we have shots of the systems at time t0, t1, t2, tn. All the information units captured at time t0, t1, t2, tn are chained by a common factor, the capture time. So we would have:

chain of units capured at t0, let's call it Ct0
chain of units capured at t1, let's call it Ct1
chain of units capured at t2, let's call it Ct2
chain of units capured at tn, let's call it Ctn

every chain is a entity. Now, except for lots of experiences collected by every individual, what makes an actual "behaviour" for an entity is a "trend" in acting. Let's assume that a system collect pieces of experiences as our theory says: scanning the system at time t0, t1, t2, tn, but until there is not correlation between these small experiences, there is no bahaviour. Now: what happens if the system tries to link together Ct0, Ct1, Ct2, Ctn in several empiric way, where only succesfull chains of chains are succesfull ? Assume that a chain is not only made by values read from virtualized sensors but also by value written on virtualized actuators (why a shot should be only made up of read value ?). Let's assume that the system core has a population of relations between t-chains. If this problem is migrated in a competitive genetic context, only links that are succesfull will survive.

Note: an info unit is an abstraction of an INPUT or OUTPUT agnostic piece of information, part of ONE experience the system had a t time. The knowledge shape (as we imagine a knowledge base as a multi dimensional space) is made up of relations. Relations constitute the population of a genetic compuational model. The fitness function is empiric, at is just a calculation of the success of Ct0,1,2,n linke in different way. Direct feedback from the system will help in correcting the links between micro chains (Ct0, Ct1, Ct2, Ctn). This will add information composition, that is relevant in terms of system response quality. There is a way to experiment this approach and create a perfect model to train and measure (take this as a reference model) the system. It could also be built by code. I'm going to describe my idea of perfect model success, where T-chains linking has been completed successfully:
take a ball, a virtual ball. Put it inside a box, a square box. The ball is the system covered on its surface with sensors, virtualized abstracted sensors. Move the ball-system applying a small force. The ball will bounce on a surface inside of the box where it is contained at time t0. After the bounce at t0, the ball will move in the box and bounce somewhere else in the box, at time t1. This again and and again at t2, tn. The ball can read bumpers and regulate, measure also its velocity and direction. Well, if the ball-system will be able to correlate this info units-chains captured via shots at t0, t1, t2, tn, at a certain point the ball, will stop itself far from every box wall, maybe at the centre of the box volume. Crazy idea, but, what happens if the system if applied to this experiment and the difference (in a mteric system, on every coordinate axis) between the perfect centre of the virtual volume and the position of the ball driven by the real system, is the measure of the quality of the response ?

An idea...

2008-02-25T20:52:00.000+01:00

Please doc Mud, since today don't post comments but enter the blog and post directly as it is too difficult to read and write playing with comments.

Welcome doc Mud.

Godzilla :]

Info linking architecture design slowing down

2008-02-25T00:27:00.000+01:00

There is a design problem about the info units and the knowledge base structured space. Because of this it is necessary to review the design of the patterns that build the knowledge base via info unit.

In the meanwhile, the low level tiers of the code are going on, new classes are going to be added and development will stop after that the code will be at the point of being able able to provide the simulation labs. This because the abstraction is decoupled from any other component.

Remember, code is growing at:

code on google svn

Logical system architecture nightly build. Please, read me again tomorrow morning.

2008-02-21T23:49:00.000+01:00

Thanks to the contribution of Doc Mud it is assumed now that it is possible to use genetics algorithm to translate info unit chains into "generations". It will also possible maybe to decouple the virtualized swarm made of info units, from the visitor that will explore units tp apply composition logic. In this way it will be possible to do somethinf very interesting: change the translation analysis context keeping the same info unit (bees and bees chains) producer. I try to explain:

Informations producer is always the virtual swarm made up of info units priduced by virtual devices.

The information consumer is the logic using the swarm of inormation unit to compose the system knowledge base shape (called shape as we like to think to this code object as a 3D space reshaping every time it is enriched with experience).

Delegating to a proxy between the info producer and the info consumer, the logic used to manipulate available info units to enrich a knowledge base can be changed without redrawing the info producer. Less system parts to rewrite in case of error, more time earned. Hmm more than a computing model can be applied to the swarm in order to make comparison and change the system computing model. It will be necessaru ti ad some more drawing.

Recap on the fly:

Physical devices are abstracted by the virtual world, via an HAL impl.
Every real device is forwarded inside the reality of the virtual world via a virtual device alias, to decouple, generalize, allow testing and data mutation/inijection

Every device alias has n channels, one for each port it has on the physical device it is mapping. Every device alias is registered in a suitable logic repository.

Every channel is registered in a repository, almost the same it happens for virtual devices.

At a t time, the system read all the channels that are INPUT capable, as all the channels "observe" the same observer-notifier.

This, via the channel repository, will cause all the virtual device channels to wake up, read (if they can) and communicate a generalized and channel and device independent DTO, keeping the value found and the read metadata.

All these infos-DTO will be a shot of the system

Every inofmation unit generated and part of a shot will be activated becoming a bee of a virtual swarm in a virtual beehive.

When an information unit DTO is activated (let's say because it implements a Runnable paradigm as well), it becomes a bee too.

Polymorphism on info unit makes it possible that an info unit is also a thread worker and when activated is it a bee.

This is the information producer subsystem

A proxy for the bee swarm computing logic act with bee creating info units/bees and hiding the algorithm build a polymer of informations/bees that cause the system knowledge base to reshape. System knowledge base is enriched by an hidden login working with the virtalized swarm.

Good night.

Analysis via context migration, this to define the way composable information units build structured information space

2008-02-19T23:52:00.000+01:00

Ok doc mud, let's adopt a problem context migration problem solving approach. Let's adopt a competitive space, for genetics evolution. It can be important to define some minor points.

Information units are bees of a virtual swarm: [info unit] -> [DTO for data linking and association] -> [runnable DTO ?] -> [bee]

All the information units created in a shot makes a chain and this is a generation.

The fact that in a shot all the information units (-> bees) have been created at the same shot time "t" is extremely relevant. This says that the approach of considering timed shots capturing is coherent with the rest of te theory.

Let's go to see your post doc mud, but the fusion of genetic programming on a virtualized swarm computing model needs more care.

DTO domains separation

2008-02-19T23:44:00.000+01:00

Change problem context, moving it (the problem) in a more comfortable one (context)

2008-02-19T00:58:00.000+01:00

The challenge is to try to imagine the software problem of information units composition/chaining as "chemical bonds", as links between composable info units. May or may not be a way to find a solution, but it is a so strange and interesting analysis approach, why not to try ? Can a person extract a problem from its original context, forget this context and translate it in another different context, to have a different and more familiar (for our brains) point of view ?

Composable info unit composition, message from doctor Mud needs a response

2008-02-19T00:26:00.001+01:00

I saw that comment, doctor Mud :] (Vincenzo) and that's the most interesting issue about phase 2 of info processing. Let's assume it is feasible to abstract virtual device alias, and to let them produce generalized information units. Then, let's consider this type of DTO, where info piece of infos move through the pattern of INFO THREE STATES. To solve this very "delicious" problem, I'd like to suggest a new approach in designing software, this is a game, so it is possible to say silly things. This approach is based on the idea that every software design problem and every sofware entity partecipating a component model, can be seen as a physical virtualized world, where it is possible, for software agent and software design problems, to apply physical laws and a 3D spatial model. I hope this will make eaiser to view the entities and the problems, for software. In our case: let's immagine the information unit as spheres, floating in a 3D space, where a sort of Coulomb law is valid for these "balls". I want to suggest not to proceed with a statinc rule based linking approach. Let' suppose these balls are able to manifest spontaneous attaction, according to their intrinsic nature. Nature defined by the information features itself. It is like to have some magnets with more than the usual two poles, in a gel. Is it possible to imagine a law that define spontaneous chaining by these information units ? Doctor Mud ? Do you know that strange vegetable that produce green balls with small hooks ? Look here to the Bardana plant.

As I hate cold numbers, let's proceed with a pure qualitative approach, and let's extract the number at the end, from the running prototype, just to evaluate the prototype success and quality.

2008-02-19T00:21:00.000+01:00

It is relaxing to do software analysis this way, it seems to be the "take it easy developement model" :)

Code is here, growing slowly with theory

2008-02-17T21:45:00.000+01:00

A simple shopping list to build this theory compliant non linear system:

The system will be made up of a virtual system able to generalize and reduce the order of magnitude of informations coming from the environment where the system has been put. The virtual system is important because the target of this blog and game, is to obtain (also if simple) a system running for a proof of concept. This could be also an evolutionary prototype in a reiterative incremental developement model, if the system will be interesting.

Actuators will be abstracted in the same way, via virtual devices, speaking from a virtualized simplified reality versus the external real world. The intent of the virtual world is to generalize and simplify, abstracting and decoupling system tiers.

An hadrware abstraction layer able to generalize a generic device interface and the I/O calls to the underlaying hardware layer. An inventory object will implment a visitor pattern and load all the interfaces/device abstractors.

Every virtualized sensor/actuator will produce an abstracted basic simple unit of information. This will be a sort of DTO able to carry the value received/transmitted, the type of operation (I or O), the name of the virtualized device that generated or processed data. Every device has one or more communication channel. This because every virtual device (or device mapper, or device alias) can have more then one only access to hardware resources. Every device has one or more channel.

The system try to use swarm computing, but the swarm will be made up of software bee, in a virtual beehive. Every bee of this virtual swarm computing will be the previosly described basic unit of information. This DTO will be an anomalous DTO pattern implementation, cause it will be also a worker for a dedicated thread. The DTO of the piece of information built by a virtual device, will run autonomously to link with other information unit, building chains of information units. Chains can be linked toghether, to obtain longer chains. This will be the virtual swarm computing model for this system theory.

With a given frequency the virtual system state of all the virtual devices mapped on the virtual world, will be captured in a sort of virtual devices shot.

This will be a collection of unit of informations running everyone as a stand alone thread and build link-correlation with other information unit and with other chains of information units.

Let's call the group of information units captured in a cycle of reading virtual devices status, simply a "shot".

This first shape of the state of the system is the status of the system at a "t" moment, and it is also the current system status to who the system itself must provide a response/resolution. This system status will be then digested by the virtual swarm and made part of the knowledge base of the system.

The system has three states and three different names:

1 Shot of the system. At a certain time all the virtual devices status are captured and some information units are created. This is the system shot. This is the question the system must provide an answer with, before becoming part of the system experience.

2 System shot is digested and the "n" DTOs composing this shots (DTOs are composable information units) are animated as threads. These threads are all bee of the virtual swarm that live in the virtual beehive.

3 Shot has been digested and more and more links are built in terms of association with other information units and chains of information units. This will cause longer information units' chains to be built.

Code is growing (slowly) here:

http://code.google.com/p/swarm-i/

Non functional requirement notes

2008-02-17T19:20:00.000+01:00

Before proceeding to the code, let' s define some non functional requirements notes. Usually intelligent systems need to performe real time processing in a very fast "pseudo real time" way. It can be interesting to change this approach, but first of all it is fundamental to define the parameters to measure the quality of a non linear system response. If the non linear pseudo intelligent system is seen as a black box, let's try to point out the quality parameters for the results produced by this box. Some elegible, not "exotic" parameters for system response quality can be:

1 Time requested to produce an output, after that the system has succesfully received, validated , accepted the input data.

2 Assumed an IDEAL perfect answer for the input given at point 1, it is possible to define the difference between the perfect IDEAL answer and the REAL answer produced by the real system. The difference can be evaluated for simple systems whose values can be obtained in any metric reference system.

Let's assume that there is a functional dependency between the time taken to produce the answer and the answer quality:

Response Quality = f(time taken to produce the response)

As the target of this experiment is to obtain a sort of answer, let's slow down the system.

As the parameters to define the system response are two, it could be interesting to choose parameter 1 as quality parameter to reduce. Let's state: it is possible to have a system that takes a some time to produce a response.

Because the system works with some information correlation technology (building a virtual swarm of info elements that need correlation) let's reduce the response time and give time to the info correlation phase to build deeper links. Let's analize now for a while, what happens limiting the time used to performe information correlation. With less time to scan composable information unit chains, links that will be build will be mainly "surface" immediate links. Let's say simpler links. Giving more time to information unit/information chains correlation, the links produced will be "deeper", more in numer, more complex. This is interesting as it is possible to have a view of the meaning of the generally valid function:

Response quality = f(Time taken to produce the response)

expressed in the context of this real system engaged in the experiment:

if we state that:

(Time taken to produce the response) = (Number and depth of information unit links and associations)

accepting a response time decrease we should observe an increase in the response quality. This is a very simple and logic assumption that doesn't need a blog to be accepted. It is now simple to catch a sight of another important parameter, that could be more relevant then the other two. If this "f" correlation (or assumption) is correct, this means that it not only acceptable to have good system response in short times (at least for the system drawn up to now), but also it is not possible at all. Let's introduce a new quality parameter to enrich the metrics of system quality:

3 Number of guaranted and quality fixed responses per time unit

This because according to the needs of the system produced data consumer, it could be better to have a constant number of response per time unit, OR a constant response quality, no matter the response time. This, of course, is a matter of usage of the systemn designed. If the relation assumed is corrected, it should not be difficult for a system provide with a quality feedback agent, to auto-regulate the time spent to link information units, and the depth of links built. This in order to handle the oscillations of the two main parameters. Let's assume, so, another function (if hardware capacity is a fixed constant):

Number of guaranted and quality fixed response per time unit = f[(Response quality),(Time taken to produce a response)]

A sort of master quality controller can handle info unit processing depth and response time, to act as a feedback retro-active agent, to keep parameter 3 (how much constant is the way the system asnwer) stable. Well, in a certain way, let's keep in mind that sometimes system could need a sort of "nap" to have a complete full information linking phase for a quality best-effort answer, no matter the time :)

System architecture proposal

2008-01-29T23:42:00.000+01:00

Here follows my last updated idea about the system architecture, this is the fruit of my night time meditations:

Recap to go on

2007-12-24T00:17:00.000+01:00

Ok, to go on now it is really necessary to recap and put order in all that stuff I wrote about up to now.

Composable information theory is just my idea to represent evolutionary and relational information derived from the interaction with the abstracted virtual world. It is something like applying collaborative info collations (information unit chains) with an intelligence working with it.

Has been now understood that somewhat logic able to work with these information unit chains is needed. It is necessary to define this "logic" before proceeding.

Data and business logic, just for fun

2007-12-24T00:01:00.000+01:00

If I remember correctly, two of the 5 tiers in a J2EE architecture are the resource tier and the business logic tier. So, in the resource tier normally we have informations stored in different types of repository. The other tier contains only the logic to manipulate data, and infact it is called business logic tier. Then we have a SOA architecture where all business logic functionalities are kept connected and available as services, but this is another story. Ok now, as here we have no client tier by now, no presentation tier, no integration, by now, let's remap the structure organized by the composable information units into the resource tier while we need to map the logic to manipulate this structured tree of data, into the business logic tier. This second remapping action is the second ingredient of two in the mix I told about before.

Composition is one ingredient in a mix of two.

2007-12-23T20:17:00.000+01:00

Let's google for some docs, let's see what comes out: many documents say that the most interesting approach is the "collaborative programming", whose meaning I'd like to adapt to my intent. Let's redefine collaborative programming something that let me create a software bee, or ant, or whatever swarm unit, to put in a software world where evolutionary behaviour can reward the unit whose behaviour is the best one in terms of target tasks accomplishment, Ok, now let's put a wide high level scenario on this and let's see what are the common trends:

1 Neural network
2 Virtual, collaborative, swarm programming
3 My simjple game, composable information paradigm programming, that's what I've been playing with here sinnce now.

The intent of this absurd and shy comparison, is just to find an element to add to my composable information paradigm game, in order to have a new approach that is not just a clone of the first two ways. Infact it has the idea of "information changing and assembling" but it misses in my opinion an active side that is somethijng more than linking similar pieces of informations. Let's see the list of features I added some post ago:

Persistence of knowledge
Events correlation
Rules for "good" and "bad"
Abstraction, combination... in other terms: information composition

I can say I have an idea of points 1, 4, but misses a component for point 2 (3 doesn't matter by now)

2007-12-20T19:23:00.000+01:00

I have a question: what's the difference between swarm programming (where the swarm population is not made up of devices, of elettromechanical units) and neural networks ? Is there a virtual swarm programmin model, where behavioural composite programming can benefits of a logical model ? In other terms a swarm of software units whose every unit contribution is the same as that one of an "ant" or a "bee" for a real swarm. In these cases the trend of the swarm get advantage of the successfully trend of a unit. Units strive to "accunulate" around the correctly behaving one. Correctly means succesfully in terms of unit life intents. A neural networks is still a cooperative system ? Maybe not, as at the end of the day I see a neural network as an information unit weight router and switcher, every unit, every neuron has NO behavioural intelligence (a threshold is not intelligence). On the other side, a neural network is a good computation pattern more abstracted and recyclable. A swarm programmin seems to me another way to obtain neural networks results, with less generalized engine algorithm. Is this last one more "modern" and less computation power consuming ? I need advice.

Defining the model to study the compos-able :] information unit problem

2007-05-07T01:15:00.000+02:00

Let's find a model to drive the technological archite
cture definition. To have an idea of what will be a composable information unit, we need first to have alook at it. As this would be the egg and the chicken problem, to have the composable information unit and to have it to study its nature and obtain the composable information unit itself, maybe it could be fine to dive into the world the composable information unit is an essential part of: let's create a virtual information unit generator, the simplest one, to derive the CIU itself (CIU is for me a Composable Information Unit). The simplest CIU generator is a virtual device able to do I/O and to generate according to its nature, some CIU. This will turn some light over the problem. Giving back a look at the virtualized world that was defined at the beginning of this blog, in the http://bp2.blogger.com/_rKqLpsM5GmU/RaBJ4N1sUiI/AAAAAAAAACI/nohJ78oQWFo/s1600-h/HighLevel.png picture we see the virtual INPUT and OUTPUT devices. To use a model driven architecture to build the first CIU, let's use the virtualized world model proposed (again.. the one in the picture). This model can be seen as a physical one. Where pseudo physical rules rule. So, first step to dig into a CIU nature, is to define the simplest of its generator. This is possible, and not a recursive non solvable problem :]

I will build first a CIU generator: a virtual I/O device. This will drive next steps and give advices on the CIU features.

Eureka for me ! (I spent so much time in the traffic to find a solution)

Attempt to define the surface for a composable information unit

2007-04-26T00:19:00.000+02:00

Trying to approach a simplified version of the problem: how this composable information unit surface should be ? These features will define in other terms, how this unit will be able to link to other units, then to build unit chains. Features of the surface should be "stuff" like:

http://www.dimi.uniud.it/~tasso/introia/sld017.htm

:)

Sizing the effort

2007-04-16T00:32:00.000+02:00

The next part of this work and all that is already been done is intended for very simple systems, NEITHER TRYING to REPLICATE COMPLEX INTELLIGENT SYSTEMS, nor human one of course. The pouposes of such a system is to be able to learn from experience and increase the quality of reactions for a very simple set of input.

Reshaping of the basic information unit composition problem

2007-04-15T22:08:00.000+02:00

Information unit can compose and link each other. To enable this idea it would be necessary to build a suitable information unit surface. The problem of "software experience" now reshapes. The problem some days was to build a composable information unit; now it is to be able to build this information unit surface, as to make it able to do linkage. This linkage surface is the repository of the logic linking criteria. Maybe the information unit (the IU) is empty inside, as nothing is more important than the abilty to created links and therefore "chains" of informations.

It is now relevant to proceed defining the features of this surface. Digging into these "details" it becomes necessary to use some technical terms, maybe near the code language.

Simple composable information unit

2007-02-22T09:47:00.000+01:00

So,

the problem has now changed, the issue has moved to the need of having a new element, that is a self sufficient very simple object, whose shape is like a "ball" with many hooks. This information-balls :) flow in the environment and for their nature are able to link each other according to basic logic operations, like analogy, completion... and few others. This object can be a single thread, trying to build long chains of information units, like the components of a DNA. Just to play on this: a "threaded hashtable", serilizable, that links other information units. These chains can be cut and composed as well, and of course can be read and saved to keep memory of the knowledge acquired. I suppose that after that this chains have been built, it is simple to continue on a reiterative process, to make the system more and more complex. It is then a software problem, to read the chains and execute the logic kept in these. Hmmm... looking at this they seem an evolution of a neural networks and synapses, but not from a computational point of view, from an information composition point of view. Am I wrong ? World ! What do you think about ?

Compose-able information unit

2007-01-28T23:38:00.000+01:00

It is needed the creation of a compose-able informstion unit, an evolved way to represent informations. Thus is possible to proceed with generalized infos composition.

Reiterative incremental (pattern based ?) information composition process

2007-01-28T23:28:00.000+01:00

Interesting: it is not necessary to "understand" the information, to make it part of an "information composition" process !!! :) Veeery interesting. Moreover, it is not necessary to compose always the same informations. Already built pattern, and compositions can be stored in the knwoledge base and pattern recognition technics can help. This make the information composition something more evolved: reiterative incremental (pattern based ?) information composition process.

Information composition and data input load mediation layer

2007-01-28T23:07:00.000+01:00

To create entropy in the system, we can assume that an information composition agent can be useful.

Note: this is a concept, non a solution. To achieve the generalized composition strategy, many nested strategies can be used.

Note: with composition I mean mean not only analogy, but also other composition "algorithm" like negation, data patterns and data models etc.

Note: an artificial system, that wants to aim to hit off "reasoning" on data, can't hope to replicate the whole wide range of informations and composition "algorithm" humans have. Of course, to build something simple and possible, it is necessary to identify a subset of reality, a subset of composition "algorithm". For this pourpose, is again useful to have this "agent" living in a virtualized world where the coder can define rules, adding a layer between the so complicated real world, and the ability of the system. At this point I have another reason to insert the virtualized world between the system core and the real world massive input production. This element would be now also playing the role of an "information load" mediator.

Entropy engine, again

2007-01-28T22:34:00.000+01:00

Let's recap: the entropy engine is the core of the decision making: it should be something able to do simple I/O operation towards the world, and then "evolve". Let's think to the behaviour of a baby. He starts just experimenting the world, so touching things, and accumulating informations. Then he is able to correlate simple events. Then, again, more complex events. Of course, he is human, and from this point of view he has big "computational" capabilities. Let's simplify this process, just to give a look to it: the baby starts doing associations, from generic informations he receives from the world. Some inputs generates positive reactions, some others end making him crying. The baby gets informations, apply some sorts of rules, prduce a reaction.
An example: if the baby hears the mother's voice, he smiles. If he is hungry he starts crying. More important: after the baby has touched a very hot object, he never will do it again. This means:

Persistence of knowledge
Events correlation
Rules for "good" and "bad"
Abstraction, combination... in other terms: information composition

This is maybe very important: information composition, a key concept in my simplistic view of intelligence

The entropy engine

2007-01-28T22:10:00.000+01:00

Let's assign this task of creating entropy in the system life routine, to something, in order to further understand the nature of this agent. Let's call this the entropy engine. This will live in the emulated world created by the whole software.

Does it exist an "open source" like research approach on these themes ?

2007-01-10T11:18:00.000+01:00

Does it exist an "open source" like research approach on these themes ? Active on the web, that everyone can join and try to contribute and get ? More or less it is like (maybe just is) software, with some more discussion.

What to replicate ? How to create "incoerence" in system behaviour ?

2007-01-08T22:24:00.000+01:00

So, it is obvious to me that the system for the decision maker as it designed by me now is absolutely still linear and not, let's say "creative". It is missing something very important that can generate new schemas, new rules for the rules engine foreseen by the system. At this point a model is needed: a human intelligence model or something completely new, with different "rotism" ? Both of them are maybe too diffult, let' s try to make things easier... let' define something theoretical and then dig into this:

A system to be useful must exist --> system must take care of itself --> simple needs must de outlined --> system must guarantee that rules enabling surviving must be accomplished.
System must save experience not to repeat always the same errors. It could die in a loop with the same error, first rule wouldn't be satisfied.

Hmmm... assuming that the system is able to achieve these two intents, what would happen, would they be sufficient to have a "good" system ? (I need to define the way to measure how much this type of system is good)

No, it is not suffiecient, the system would map the environment where it moves and not do anything else, stopping. Stopping for this type of system, in my opinion, means system died with no success. The knwoledge base of the system, in this situation, would be useless, as the system would know just walls, but no other data, no other need, just inactivity --> limited knowledge increase.

3. Target of the system is a continuously increasing knowledge/experience base.

The question, so, has now changed: we still don't know if it is better to replicate a human like approach to reality, or a set of new ideas. Let's choose the second and integrate with human ideas where the gap is too big to jump over.

Target: how to make possible that the system is always capable to find a new trigger to continue the learning process ?

More details on the decision maker agent

2007-01-07T02:15:00.000+01:00

Attemps to better define decision maker internal logic.

It is important for this software to save the experience gained. This build non linear behaviour from data, not from algorithm, this should be genetic to do this. what would happen if most of the software could gain experience ? Could be usefull ?

I'm not yet happy for this drawing... something I feel is missing. Need to investigate.

IMPORTANT, ESSENTIAL REQUIREMENT (idea from the night :] )

2007-01-06T10:41:00.000+01:00

SOFTWARE MUST REMEMBER/SAVE THE EVOLUTION AND THE EXPERIENCE ACHIEVED IN THE PREVIOUS RUNNING SESSIONS OR IN THE PREVIOUS DECISION MAKER INSTANCE LIFES, OTHERWISE IT IS USELESS. THE MAIN INCOME OF THE SYSTEM IS AN ENRICHED KNOWLEDGE BASE THAT CAN BE REUSED ALSO IF THE SYSTEM CHANGES (FOR EXAMPLE IS PERIPHERIALS), AND VERSIONED. OTHRWISE IT IS LIKE HUMANS HAVE NO SCHOOL, AND EVERY TIME THEY HAD TO REINVENT THE WHEEL.

:)

THIS IS IMPORTANT. VERY IMPORTANT. OTHERWISE NO SYSTEM EVOLUTION IS POSSIBLE.

Pause prototyping and move on with lower level analysis

2007-01-04T23:03:00.000+01:00

It is important to detail when the network numeric computation is used: some more detailed analysis is needed on the architecture of the decision maker. The virtualized world is in some way simpler to understand and with less risks.

A test on the network prototype takes too much time

2007-01-04T22:59:00.000+01:00

It takes too much to compute ten input value on ten layers, 10 neurons per layer, using BigDecimal values with "," maybe it is better to test with integers and then performe some post processing on the result values. Maybe.

Software evolutionary prototypes, faseability

2007-01-04T22:50:00.000+01:00

It is now time to proceed with some evolutionary prototypes :)

2007-01-04T22:30:00.000+01:00

Starting to write some code, to define faseability for the hottest part: the sigmoid with back propagation, after some tuning on the values for weights, we have (code will be soon available):

These drawings are the result of the network procesing, providing a data model and real data. The red small boxes are the point produced by some ten neurons test, working only on Y.

2007-01-04T22:11:00.000+01:00

An idea, not yet defined in details, these should be architectural components:

Another note on my ideas

2007-01-04T00:10:00.000+01:00

I ask to myself:

when the first of a new one decision maker is created, it needs to find devices in its world: curious question: when a baby discovers his/her hands for the first time, does he/she know that that is an hand ? Ot it is known to the brain just as an "endpoint" ? Does the prisoner, the decision maker needs to do an auto mapping of all the terminations (or endpoints) that are present in the prison ?
Terminations can be grouped into two classes of elements:

1 capable of reading input from the world --> TERMINATIONS_INPUT
2 capable to modify - dping output - the virtalized world TERMINATIONS_OUTPUT

Hmmm, a termination capable of doing BOTH INPUT and OUTPUT from the world, is not one, it is two :)

and it could be discovered two times. No one needs to be aware that a termination capable of input is the same of one capable of output.

I can change my way to say, now, in accordance with this new idea: the auto mapping will be done on all the input interfaces and on all the output ineterfaces, where the distinguishing element is the input and output ability.

!!!! A piece of code developing a terminations capable of providing 3 input terminations, is one for the author of the code: they are 3 input terminations for the system :)

Approach to analysis

2007-01-04T00:04:00.000+01:00

Strange element to analize in an OO approach: maybe I can try to use a reiterative incremental approach to have contimuous checks and feed back from my ideas. In this case tiers and layers are not common, layers will be just few, maybe; tiers: I need to think on this. Can't use a J2EE or SunTone (r) architectural model, not suitable in my opinion for the tiers I can see in the fog I still have in my plans :)

Need some thinking on this.

Ideas on "soft" architecture

2007-01-03T23:30:00.000+01:00

The system will keep in it leaving a nucleus free to behave and with a sigmoid back propagation engine, capable of some computation. Available to this numeric computational engine, will be a knowledge storage, as an in index of models available for processing by the numeric processor part of code. Looking at this:

http://www.youtube.com/watch?v=TFnsjDDnLck

I had a funny idea: a software agent capable of taking pseduo itelligent decisions, can't be more or less in any way directly interfaced to the real world. It must be left free to behave, "sure" to live in a world more suitable for its nature. For this funny idea, the "intelligent" agent will be as a prisoner in a virtualized code world, where it can do whatever he wants in an easy way for the coder and the tester. This virtual world will be instead a quite stupid software shell that - without saying the reality - to the intelligent prisoner, will translate real world data coming from sensors, into changes in the virtualized code world. Viceversa: every modification introduced from the intelligent prisoner (the computational intelligent decision maker) will be transformed to "impacts" on the virtualized world, and this virtualized code world will translate these modifications received, into output for actuators, for example. The virtualized world of code, the prison ( :] ) is just a shell simulating a convenient environment for my system kernel.

To recap: an intelligent decision maker using a network with back propagation numeric engine will live and behave and evolve as it likes, in a world that will undersgoes to the actions taken by the prisoner. This component will be called by me as the "prison". It will also change to the ineterface exposed to the prisoner, in accordance with what it will read via sensors from the real world:

1 prisoner-decision-maker
2 prisoner-decision-maker world (transponder from/to reality)

at this point a note:

the prisoner-decision-maker has rules, and priorities, has needs, has life conditions, and can die if it will not be succesfull. In this case a new generation of decision maker can be created automatically by an entity, a sort of "provvidence", to continue the system living. The prisoner death (a big system failure) event will be kept in the experience of the whole system, to try to avoid the same mistake again.

2007-01-03T23:17:00.000+01:00

Software will be "non linear": this means that it will have an evolutionary routine and a sort of knowledge base. As time passes, the experience of the system need to evolve and cause the response of the software to be different. The system (made up in its scope of software only, at this stage) will keep experience also when switched off. It is expected that the software will be able to be better as "time goes by".

Software will use mainly java :)

Software will use Linux :)

Sources, also if with no value, will be open source and available to everyone who wants to loose some time.

Software will have lot of bugs :]

Hmmm... aree bugs some spontaneous native code intelligence to subdue ? Bugs... what a mistery are they.

Steps to proceed

2007-01-03T22:47:00.000+01:00

Here follows a list of possible steps to go through (as this is an experiment, it can be found to be NON FEASIBLE at a certain point):

Main steps:

1 Create software as I want and can
2 Choose that hardware that is suitable for software needs and costs
3 Assemble 1 and 2
4 Tune
5 Find capabilities and hard limits

Nested steps:

1a Define requirements, what does this software need to do ?
1b Refine dreams with reality (skill, costs, time)
1c Increase success chances, build a prototype, then new versions, possibly everyone richer than the previous. This means obtaining results, and continue...

2a Choose hardware that will fit software, keeping in mind that this will be a mobile platform: software decides hardware.
2b Evaluate the whole cost: do/do not continue (the software will be the only deliverable: this is an experiment, I can do this)

What is this ?

2007-01-03T21:27:00.000+01:00

Hello world :)

This is the diary of my experiment to play with code and robots.
I don't know theory, I have bad English but at the same time I love toys going around autonoumously. I'm not a student, I didn't graduate in electronics or physics, I have neither theory nor experience with this type of stuff but I like it, and being so ignorant in this allows everyone who wants, to give me advices.
This is only a game I play because I just like it.

Take it easy :)

caramelleas