Stitie Machine 1.1 'Sunsail'.

Stitie Machine 1.1.35 RC 0-0-5 'Sunsail' implementation is available.

(RC stands for: 'Release Candidate', Alpha means 'feature incomplete', Beta means 'feature complete, to be tested').

What is this code about?

it's an experiment with Information Technology.
i've tried to help as many as possible in shortest time guided by insight. that's how it was formed into existence.
it's a technology that can solve certain 'problems' better than others, and at solving other 'problems' is worse.
it's incomplete still, and aimed to truly shine at certain point in future - when processors & memory are cheaper.
it's pointless to develop tech that exploits modern computers because by the time it's complete there are better computers already.

'Stitie Space', 3D Objects Matrix data structure, has certain unique 'convenience methods' that allow for a 'fine manipulation of objects' in 'computer memory', a space to be filled with numbers in itself, perhaps ...

these numbers belong to a usual set of {0,1} that is found in 'Computer Sciences' ...

any 'number' or 'other data' can be represented with proper amount of these numbers ...

Stitie Space's 'convenience methods' include:
- MATEN functionality,
- Prism functionality,
- Finite State Objects,
- Conditionality & Events,
- Mindful Imaging functionality.
- perhaps more ...

for more, see if You wish or need, ... : Agile Transformation of Information State.

perhaps in future this will allow to control clouds of robots of different scales.

it's unfinished high level prototype of 3D Objects Matrix, that allows for fine manipulation of objects in space (in computer memory).

MATEN Form functionality is a certain form invocation in space.

controlled robots will be able to (perhaps) take different geometrical forms in space & 'update' software via upload from matrix.

if robots are so small that not visible to eyes, then it can seem that form materializes in space & transforms space.

such a miracle from machine (Deus Ex Machina).

i'd call it 'Pseudomaterialization'.

i've planned (this can change) to implement election algorithm to choose 'task-givers' to groups of robots, for example in a case of failures.

not only that.

Main Features List:

* Stitie Machines (State, Strategy, Router) forming 3-Dimensional Stitie Space (3D Objects Graph that looks like cube of objects connected properly). Let's note that (State + Strategy) is equivalent of an Object as in Object Oriented Programming. Router is a tool that can be used to move States & Strategies to other coordinates. Executing a strategy after moving at certain coordinates is also possible with Router objects.
* MATEN functionality (Certain Form Invocation in Space).
* PRISM transformation. It will transform space taking set of Coordinates and LightPoints at such as input. 'colorful points of light in space will be split and transform space'.
* LightPoints. Point of Light is (State, Strategy) pair, an equivalent of an Object. (color is determined by state and strategy pair, strategy determines also changes in color; color includes lighting).
* Mindful Imaging Prototype (depends on JOGL).

Sitite Machine version 1.1 'Sunsail' is considered closed, only allowable changes from now on are error-fixing.

Work will continue in Stitie Machine 1.2 'Satellite' & perhaps in Stitie Machine 1.3 'November Rain'.


Notes for MATEN functionality:

It's a Maneuver in Space. We'll add Maneuvers to Space and name them. Then invoke MATEN function with a Maneuver's name as a parameter, which will return Space to 'zero' state then invoke that Maneuver. Or will do magic that will result in something equal but more efficient. Result of executing a Maneuver is a new Form.

Example code, for preparing for a MATEN invocation:


    MATENManeuverStrategy mms1 = new MATENManeuverStrategy(
      new EmptyManeuverStrategy(),
      new DefaultZeroManeuverStrategy(matrixA));

    matrixA.addMATENManeuverStrategy("emptyForm", mms1);

Code above adds an 'empty form invocation maneuver' to a Space (which is a '3D Matrix' in this case).

This 'empty form' on Matrix A can be invoked like that:


When invoked, default zero maneuver strategy will be called if space is not in the 'zero state'. If called, it will return space to the 'zero state'. Then empty maneuver strategy will be used, which will do nothing. In the end we'll have an empty form, space is in the 'zero state'.


Basic (without graph or other magic involved) functionality implemented.

Current implementation of MATEN functionality is not erroneous, we do not want to store last MATEN maneuver... we wish to allow for changes after executing such. Return maneuver must be abstract enough to allow for all situations that are considered. There will be default most abstract return maneuver implementation but we wish to allow for better solutions as well. In certain situations we won't want to just empty all states and strategies, we wish to store them for transformation as input data for later, Invocation maneuver. It's best done with new programming language: 'Ola AH', for concurrency is an issue for now.

For now we have 'Default Zero Maneuver Strategy' that returns space to the 'Zero State', where strategies and states are empty, without remembering strategies/states from previous Form.

There might be concurrency errors if MATEN is used carelessly (this can be solved with new language: 'Ola AH', or theoretically with hacks - we do not want such). Hack is something done not according with design.


Some more tests:

Test #1: Stitie Space.

Quite slow for low resolution. (in truth, not so low because it's three-dimensional - but it's still slow).

after > 64 'pixels' resolution there are troubles, perhaps not enough memory - i didn't check very well.

optimization can proceed as follows:

- perhaps parts of Stitie Space can be optimized algorithmically. thinking about Strategies, Maneuvers, etc... not guaranteeing anything. still fairly cheap programmer time-wise.
- we can have low level optimization (both for Stitie Space & Code of Program that uses Stitie Space). very expensive programmer time-wise.

Test #2: JOGL/JogAmp.

seems that JOGL is quite fast & light, it should stay if it's not too expensive (seems to be free for now). we do not need any layer above.

perhaps 'Ola AH' Programming Language can use OpenGL as well, we'll see. certainly not as only option, there should be also option for direct graphics coding.


Dependencies used:

should work with Linux as well; i've used Stitie Space 'Sunsail' 1.1 with Linux / JogAmp before.

i didn't care (yet) about using minimal library set, it's not time for that.... perhaps files content will change with time anyway.

branch of Stitie Machine 1.1 'Sunsail' became basis for a Game Engine, which will be ported to ANSI C for speed (low-level optimization).

it looks like a Stitie Machine 1.1 'Sunsail' will be included in semantics of 'Ola AH' Programming Language.

See also if You wish or need, ... : Stitie Machine (Maszyna Stanikowa Wysockiego), High-Level Prototype, Low-Level Port, Parallel & Distributed Systems, Stitie Space, Stitie Space, Form & Emptiness.

No comments:

Post a Comment