#header-inner {background-position: right !important; width: 100% !important;}


Marketing Tricks.

does a birthdate, TAROT, Magic(k)s, Zodiac, ... have a marketing impact when promoting a product ?

i think they do, as significiant group of society uses this a kind of services.

therefore, i'll try to advertise Dragonfly Algorithm's products as Magical Software Artifacts, or something along these lines.

there can be a mention about Magic being Awakened, for Buddha means Awakened (from delusions & other distractions, i think).

with all respect to target groups, i belong to them as well ... as a Virtual Adept on Milarepa's Way, in a way at least.

i think ad's message should be subtle, the subtler Art & Magic, the better ...

... something along lines of 'Magical Moments with a Family & Entertainment'.

... click on image above to enlarge it.

... for more, feel free to look: Lucky Numbers, Karma, ... & Date of Birth.


'Ola AH' Programming Language Syntax.

(under construction, probably will change).


'Ola AH' Programming Language is targeted to Quantum Computer Architectures with the multi-core support of Advanced RISC Machines - it's designed for ARM / Quantum Architectures.

it's syntax will probably evolve as related technology advances.


what are Design Goals, what kind of language 'Ola AH' should be?
how 'Ola AH' Programming Language's Syntax should be described ?

in my opinion syntax & language's semantic should be:
* beautiful,
* elegant,
* modest,
* strict,
* mindful,
* spiritual,
* mathematical,
* philosophical,
* terse (means: a short form, but inner complexity is strictly & precisely defined; in a polish language it's translated as 'zwięzły'),
* sexy,
* short,
* nice,
* gentle, easy to read, understand & learn,
* agile,
* insightful,
* precise,
* artful,
* both esoteric & practical,
* optionally visuospatial,
* secure,
* sane,
* scientific,
* classical yet very modern,
* formal yet still casual,
* esoteric, pragmatic & practical,
* simple yet skillful, expressive & powerful,
* professional.

Data Types.

There will be 128-bit & 256-bit data types in 'Ola AH' Programming Language.

256-bit processors could be used for addressing directly up to 2256 bytes. Already 2128 (128-bit) would greatly exceed the total data stored on Earth as of 2010, which has been estimated to be around 1.2 zettabytes (over 270 bytes).

There won't be need for adressing that much of memory for many years, perhaps not in this life at all.

But i think there's good chance that sooner or later there will be support for 256-bit operations, included in 64-bit processors, perhaps in specialized processors. Operations on 256-bit numbers have uses in cryptography, perhaps in other fields as well.

256 bits is a common key size for symmetric ciphers in cryptography, such as Advanced Encryption Standard.

There's idea of 'Very long instruction word (VLIW)', instructions that operate on 256-bit numbers.

'Ola AH' should use support of 256-bit processor operations, this is enough of reason to use 256-bit long data types, in my opinion.

Unfortunately, i do not know how precise arithmetics is needed for efficient nanotechnology, quantum physics & other sciences. i just use 256-bit arithmetic support, along with big variables & fractional data type as an mind opener, hoping to inspire others to think about such needs. i am sure that even that little will have practical uses as well. One should overdo with mathematics when considering sciences, as mathematics is often a bottleneck in such applications, anyway.


enumerations (enum),

int8 - signed 8-bit integer,
int16 - signed 16-bit integer,
int32 - signed 32-bit integer,
int64 - signed 64-bit integer,
int128 - signed 128-bit integer,
int256 - signed 256-bit integer,

bigint - signed big integer, a data structure of variable length (can be resized to hold bigger numbers).

boolean - logical boolean type, with a { true, false } values,

char - a single character, 16 bit UTF,

string - character string object data type with a proper convenience methods,

float32 - 32-bit floating point number,
float64 - 64-bit floating point number,
float128 - 128-bit floating point number,
float256 - 256-bit floating point number,

bigfloat - big floating point number, a data structure of variable length (can be resized to hold bigger, more precise numbers).

decimal32 - 32-bit floating point numbers written in a form: m * 10e, where:
  m is BCD-encoded mantissa;
  e is called exponent (BCD-noted as well).
decimal64 - 64-bit floating point numbers written in a form: m * 10e, where:
  m is BCD-encoded mantissa
  e is called exponent (BCD-noted as well).
decimal128 - 128-bit floating point numbers written in a form: m * 10e, where:
  m is BCD-encoded mantissa
  e is called exponent (BCD-noted as well).
decimal256 - 256-bit floating point numbers written in a form: m * 10e, where:
  m is BCD-encoded mantissa
  e is called exponent (BCD-noted as well).

bigdecimal - a big floating point number, a data structure that uses BCD-notation & is of a variable length (both mantissa as well as exponent are BCD-noted & can be resized to hold bigger numbers, respectively increasing the possible number magnitude range as well as the number's precision).

for details about BCD notation (encoding), about mantissa & exponent notations, feel free to look at an article: Binary-Decimal-Hexadecimal Conversions.

fractional - a potentially big & precise number represented in a Base-k arbitrary precision arithmetics with PreciseNumbers. This allows for simple basic arithmetic operations without a precision loss, at a cost of memory use & calculation speed. i think it'll have great uses in science & banking - will simplify programmers' & other scientists' life a lot.


'variable' object type that abstracts over a primitive & object. with 'inspect' operation to discover contained data type, with a typesafe cast. probably a shorter instruction mnemonic of 'var' will be used.

example #1:

var v1 := 108;
if (inspect v1 = int8) { ... };

example #2:

var v2 := new MyClass1();
if (inspect v2 = MyClass1) { ... };

example #3:

var v3 := new MyClass2();
if (inspect v2 instanceof MyClass2) { ... };

example #4:

var v4 := 108;
int8 i1 := (int8) v4;

example #5:

var v5 := new MyClass3();
MyClass3 o1 := (MyClass3) v5;

static variables & constants (with java's semantics of the 'static' keyword),

Collections (with a proper syntax support):

collection can be 'flat' (tuples, arrays, lists or sets) or 'not flat' (maps).

collections will feature built-in sorting (with a default or user-implemented comparison method).

collections will feature built-in conversions to other collection type, using source collection's 'comparison method' as well.

collections will feature built-in transformation (with user-implemented 'transformer' method.

also there will be abstract 'predicate' method, a subtype of 'transformer' which will transform any input state to a boolean value; this has uses in the 'predicate logic' & artificial intelligence as well; there also will be 'constant predicates' : 'TruePredicate', 'FalsePredicate' - that transform 0-argument input state into a boolean value; there also will be strictly 'boolean predicates', as for example: 'NotPredicate', 'OrPredicate', 'AndPredicate', 'IffPredicate', 'NandPredicate', ... - that operate on a collection of the predicates & transform them into a boolean value. for a list of logical operators, see: 'Logical Operators' article; a part of 'boolean predicates' will use collections with a set size of 1 or 2, other 'boolean predicates' will accept collections of any size.

there will be default 'default variable comparator' as well, that can compare types & state differencies for two 'variables' of the same type.

shorter keyword will be used for a 'default variable comparator': 'dvcomparator'.

there will be predicate calculus constructs:
- predicates,
- terms,
- formulas,
- models,
- entailment operators,
- inference operators.

... this has uses in logic & in the artificial intelligence fields.


array of a given type, with a support on the syntax level:

  for example:

    int32 iarr[] = ${ 1, 2 };
    char carrarr[][] = ${ ${ 'a', 'b' }, ${ 'z' } };
    object oarr[] = ${ o1, o2 };

operations available on arrays:
- standard array get & set (for example: char ca[] = ${ 'a', 'b' }; ca[1] := 'a'; var v = ca[0];),
- length,
- inspectvals,
- amountin,
- contains (element),
- containsall ('flat' collection),
- clear // clears array, setting 'null' or '0' values ...,
- sort (comparator) // sorts elements using a passed comparator.


tuple aggregate ( for example: (1, 2), (1, (2,3)), ... ),

tuple differs from array in that, that tuple uses type-safety for each of it's values,

  for example:

    (int8, int8, int8)
    (object, object)
    (object, int8, float64)

tuples can be both l-values (assignable variables), as well as r-values (non-assignable expression values).

process of assignment (a,b) := (b,a); proceeds as follows:

r-value of (b,a) is copied to temporary memory, then assigned value-by-value to a l-value tuple (a,b);

in the end a variable of 'a' contains an initial value of 'b', a variable of 'b' contains an initial value of 'a';

process of assignment (a,b) := (func1(a), a); proceeds as follows:

r-value of (func1(a),a) is calculated to a value tuple (as opposed to expressions tuple), then values are copied to a temporary memory. next we assign value-by-value to a
l-value tuple (a,b);

in the end a variable of 'a' contains calculated value of a 'func1(a)' expression, a variable of 'b' contains an initial value of 'a';

assigning values from a tuple proceeds as follows:

example #1:

(char, char, char) t1 := ('a','b','c');
char a,b,c;
(a,b,c) := t1;

example #2:

(char, char, char) t2 := ('d','e','f');
char d,f;
(d,_,f) := t2;

in an example #2, the underscore: _, allows for omitting a variable during the variables assignment process.

it seems there's a conflict between tuples & conditional instruction 'if' on the syntax level.

this will be solved by evaluating a tuple to a value - first value in a tuple is r-value of a tuple.

therefore we can write:

if ( (true, 1, 3) and ( booleanVal1 or booleanVal2) ) { ... };

this will evaluate to:

if ( true and ( booleanVal1 or booleanVal2) ) { ... };

then to:

if ( booleanVal1 or booleanVal2 ) { ... };

tuple should be 'inspectable' both for it's type, the type of n-th value, as well as for the amount of values in it.

example #1:

(char, char, char) t1 := ('a', 'b', 'c');
if ( (inspect t1 = tuple) and (amountin t1 = 3) ) { ... };

example #2:

(char, int8, char) t2 := ('a', 108, 'b');
if ( (inspect t2 = tuple) and (amountin t2 = 3) and (inspectval 0 of t2 = char) { ... };


hash maps with keys of a string type & values of a given type, with a support on the syntax level.

tree maps for more efficient search in larger data size, at greater memory storage cost.

shorter keywords will be used: 'map', 'tmap'.

default hash maps with key values of 'string' type will have following notation:

for example:

  object map om1 := %{};
  object map om2 := %{ "akey" : o1, "bkey" : o2 };
  char map cm1 := %{};
  char map cm2 := %{ "akey" : 'a', "bkey" : 'b' };
  var map vm1 := %{ "akey" : 'a', "bkey" : 'b' };

hash maps with different key values than 'string' will have following notation:

(it's also possible to write default hash maps with a 'string' key type that way).

for example:

  (object, object) map oom1 := %{};
  (object, object) map oom2 := %{ so1 : to1, so2 : to2 };
  (char, char) map ccm1 := %{ 'z' : 'a', 'b' : 'c' };
  (string, char) map scm1 := %{ "akey" : 'a', "bkey" : 'b' };
  (string, char) map scm2 := %{ "zkey" : 'z', "ukey" : 'u' };

tree maps will have following notation:

for example:

  (string, object) tmap sotm1 := %{};
  (string, object) tmap sotm2 := %{ "akey" : o1, "bkey" : o2 };
  (string, char) tmap sctm1 := %{ "akey" : 'a', "bkey" : 'c' };

internally maps will be not be stored as (key, value) tuples, because of type safety.

other operations available on maps:
- clear // clears map of any (key, value) tuples,
- inspectkeys,
- inspectvals,
- amountin // returns legth of keys list,
- insert (key, value) // inserts a (key, value) tuple into a map,
- remove (key) // returns removed (key, value) tuple,
- insertall (map) // inserts all of (key, value) tuples in a passed map,
- removeall (map) // returns map of removed (key, value) tuples,
- sortkeys (comparator) // sorts keys using a passed comparator, can't be null but can be default comparator.
- keys // returns sorted list of keys,
- getcmp // returns comparator used to sort keys.

maps will resize automatically, throwing error if not possible.

by default, construct: %{ ... } is represented as a variable hash map, that is converted to a proper type during a succesful assignment.


either linked lists or array lists (tuples are not array lists in 'Ola AH' Programming Language, because of type safety).

shorter keywords will be used: 'list', 'alist'.

for example:

  char list cl := #{ 'a', 'b', 'c' };
  string list sl := #{ "str1", "str2" };
  object alist oal := #{ o1, o2, o3, o4 };

lists will be inspectable for contained data type as well as for amount of elements contained.

for example:

  char list cl := #{ 'a', 'b', 'c');
  if ( ( inspect cl = char ) and ( amountin cl = 3 ) { ... };

other operations available on lists:
- clear,
- amountin,
- inspectvals,
- insert (position, element),
- get (position),
- contains (element),
- remove (position),
- remove (element),
- insertall (position, 'flat' collection),
- getall (startposition, endposition),
- removeall ('flat' collection),
- removeall (startposition, endposition),
- containsall ('flat' collection),
- sort (comparator), // null value means unsorted.
- getcmp.

lists will resize automatically, throwing error if not possible.

by default, construct: #{ ... } is represented as a variable linked list, that is converted to a proper type during a succesful assignment.


sets are unsorted, may contain a maximum of one element of a given (type, value) pair. for this case, subtypes are different than supertypes.

by default, 'Ola AH' Programming Language will use hash sets.

a keyword that will be used is: 'set'.

for example:

  char set cs1 := @{}; // initial memory asignment.
  char set cs2 := @{ 'a', 'b', 'c' }; // initial memory assignment & initialization.
  string set ss := @{ "str1", "str2" }; // initial memory assignment & initialization.

sets will be inspectable for contained data type as well as for amount of elements contained.

for example:

  char set cs := @{ 'a', 'b', 'c' };
  if ( ( inspect cs = char ) and ( amountin cs = 3 ) { ... };

other operations available on sets:
- clear,
- inspectvals,
- amountin,
- insert (element),
- remove (element),
- contains (element),
- insertall ('flat' collection) // if collection is a set, it acts as 'union' or 'add',
- removeall ('flat' collection) // if collection is a set, it acts as 'set subtraction',
- intersect ('flat' collection).

three last operations ('insertall', 'removeall' & 'intersect') will not produce a result set of more abstract type, since these operations will affect the source set's state. this might result in an exception being thrown instead.

for example:

  char set cs := new char set @{}; // initial memory asignment.
  cs insert 'z';
  cs insert 'y';
  cs insert 'x';
  char c1 := cs remove; // removes any element, then returns it or null if failed to remove.
  char c2 := cs remove 'y'; // removes element 'y', then returns it or null if failed
                                       // to remove (when set didn't contain 'y').
  cs insertall @{ 'l', 'm' }; // inserts two elements to cs.
  char set cs3 := cs removeall @{ 'x', 'm' }; // removes two elements: 'x' and 'm',
                                                               // then returns @{ 'x', 'm' } or null when failed
                                                               // to remove both (it's atomic operation).
  cs clear; // removes all of remaining elements from cs.

by default, construct: @{ ... } is represented as a variable set, that is converted to a proper type during a succesful assignment.

sets will resize automatically, throwing error if not possible.

sets are not sorted.

Interfaces, Classes, Objects

in 'Ola AH' Programming Language objects will be represented internally as a
(state, strategy) tuple or a LightPoint but this will be hidden behind a simplified syntax.

there will be a way to extract state or strategy from an object on the syntax level; extracted state won't contain data required to choose method called inside a strategy.

... rest as in standard object oriented programming, similar to Java's syntax.

example #1:

public class MyClass {
  var a;
  public var getA() { return a; };
  public void setA(var a) { this.a = a; };

object o = new MyClass();
var v = o.getA();
state stt = o.getState();
strategy str = o.getStrategy();

(blog's author's note to self: for java interpreter's concurrency use Lock, use thread names with method to call as well so there's no collision when multiple threads use the same object).

Other Collections.

there will be a standard library with other collections, as neccessary.

for example: trees (trees can also be constructed using lists of lists or tuples of tuples or maps of maps, with differing leaf nodes. abstract data type (root or leaf node) might prove useful here as well.


stitie machine, with state, with strategy, with router,

machines' state setting using either a single-setter way, or using an elegant hash map syntax,

  for example:

    m clear; // clears state, removing all of the key-value pairs.
    m put ("akey", "aval"); // adds a key-value pair to the state.
    m putmap %{ "akey" : 'a', "bkey" : 'b' }; // adds a key-value pairs to state;
                                                                                // using default hash map
                                                                                // with a 'String' key
                                                                                // is mandatory, but it's 'char' type
                                                                                // of value is not mandatory.
    m putmap myDefaultHashMap; // adds a key-value pairs to state.
    m set ("akey", "aval"); // overwrites state of a select key/value pair.
    m setmap %{ "akey" : 'a', "bkey" : 'b' }; // overwrites state with a
                                                                                // key/value pairs found in a
                                                                                // default hash map;
                                                                                // using default hash map
                                                                                // with a 'String' key
                                                                                // is mandatory, but it's 'char' type
                                                                                // of value is not mandatory.
    m setmap myDefaultHashMap; // overwrites state with a default hash map.


stitie space, with methods as a certain form invocation, mindful imaging, ...

stitie machine & stitie space are data structures.

stitie space is a three dimensional objects array (3D Object Matrix),

stitie space uses stitie machine, is a tool for modelling & transforming graphs in three dimensional space (stitie space).

stitie space has convenience methods that allow for 'Agile Transformation of Information State' in space.

stitie space & stitie machine are introduced & described mostly in two posts:
* Stitie Machine (Maszyna Stanikowa Wysockiego),
* Stitie Machine 1.1 'Sunsail'.

probably more,



any of the instructions can be dynamically created as well, will be properly typed objects that can be 'passed around' - even 'asm' instruction, after that functionality is added to interpreter or compiler, respectively.



modes (including 'AH' mode, 'machine-less' mode, 'machine-less AH' mode, ...),

assert keyword,

basic arithmetic, expression operators: +, -, *, /, pow, ceil, floor, sqr, div, modulo, =, eq, ...
logic arithmetic, expression operators: not ( ! ), and ( && ), or ( || ), xor, imp, irev, iff,
bitwise logic,expression operators, not ( neg ), and ( & ), or ( | ), xor ( ^ ), imp ( => ),
  irev ( <= ), bitwise iff ( biff ), bitwise nand ( bnand ), shl ( << ), shr ( >> ),

assignment instruction LET ( := ),

complex instruction { ... },

empty instruction { },

conditional instruction if,

iterations & loops: while ... end, do ... while, for,

break & continue,

standarized but optional, class & method invariants & contracts
 ( assert invariant name boolean_expression , or something similar),

standarized but optional, unit tests & integration tests, based on invariants & contracts ... using invariant names & perhaps more (for example a function call can be tested by providing a mock object with assert invariant name boolean_expression in it, or something similar),


in 'Ola AH' Programming Language methods will be properly typed objects that can be 'passed around', most probably with a proper syntax support.

method objects can be statically or dynamically constructed as well, with an elegant syntax support.

static methods,

inner visibility constructs,


class definition instructions, constructors, methods, with private, package-private, protected & public visibility (had not better idea here than a Java-Way),

class destructor methods,

automatic memory allocation for built-in primitive data types,

'new' operator for object memory allocation & object construction,

exceptions (try ... catch),

'sizeof' instruction,

'inspect' instruction,

'instanceof' instruction,

low level / asm instructions,

threads & concurrency mechanisms,

perhaps class templates, simpler form than Java Generics - in future versions,

reflection mechanisms,

'transform' instruction (takes as parameters a 'variable' & transformation function that returns 'variable' depending on a 'variable' passed to it ... then returns transformed 'variable').

example: var v1 := o1 transform ft1;

'compare' instruction (takes as parameters two 'variables' in a tuple & a comparison function that returns a value (-1, 0 or 1) depending on 'variables' passed to it ... then returns a comparison value - a primitive: -1, 0 or 1),

perhaps shorter mnemonic ('cmp') will be used,

example: int8 p1 := (108, o1) cmp fc1;

both 'compare' as well as 'transform' instructions can throw an error when appropriate.

most probably lambda calculus constructs for functional programming in future versions as well (with reflection mechanisms' use, most likely),

probably there won't be any of 'garbage collection' mechanism(s), so recources release has to be done manually using 'release' instruction - because of low level / asm instructions in 'Ola AH' Programming Language,

lazy evaluation,

... perhaps more as well,


see also, if You wish or need, ... : 'Ola AH' Programming Language, 'Ola AH' Programming Language's Interpreter in Java.

'Art and Dharma Teachings' with 'Ola AH'.

... seems that 'Ola AH' Programming Language interpreter (not compiler) should be a part of 'Art & Dharma Teachings' Portal Project.

interpreter is easier, java-compatible ...

(Google App Engine infrastructure on which 'Art & Dharma Teachings' is run, uses Java, so it integrates easily & seamlessly with an interpreter written in Java),

interpreter should be completed before a compiler.

interpreter is better solution for 'Art & Dharma Teachings' Project than compiler in my fairly educated opinion.

... reason for including 'Ola AH' in 'Art & Dharma Teachings' is modelling speech forms functionality.

'Ola AH' is a nice tool for modelling & transforming graph data structures in three dimensions, but there's more ...

... including 'Ola AH' Programming Language interpreter in 'Art & Dharma Teachings' Project will allow us to write 'Art & Dharma Teachings' parts in 'Ola AH' Programming Language.

parts at first, then whole, then perhaps we can switch the whole to compiler as well ... resulting in immediate very high of speed's & memory performance increases.

> 'Art & Dharma Teachings' Drawing Board a link: [ click. ];
> 'Modelling Speech Forms' a link: [ click. ];
> 'Ola AH' Programming Language a link: [ click. ];
> this article on deviantART: [ click. ];



Modelling Speech Forms.

i think that Speech Forms & Arguments used in a Speech might be analyzed, modelled as with a Graph.

i think that 'Ola AH' programming language, once created, might help with that.

elegant dedicated syntax might allow for easier thinking & better graph transformations & analysis.

perhaps this can support even real-time analysis of speech's popularity for a target group(s).

with a varied mindful imaging visualizations, as well.

a 'Graph',
a 'Graph' of Arguments' Popularity.

if we wish to say argument 9,
let's take care of supporting arguments as well,
... it's 11 & 8 in this case.

for 11 we should also take care of 5 & 7,
for 8 we should also take care of 7 & 3,
for 5 we should take care of 11 as well.

if we wish to say 10,
let's notice,
argument 10 supports itself,
perhaps we should speak it many of a time.
it's supporting arguments are 11, 10 & 3.

this 'graph' is a 'directed graph',
for there are 'arrows' at the 'ends of the lines',

there are 'cycles' in this 'graph',
11->5->11 & 10->10 in this case,
... arguments we should speak many of a time, perhaps.

see also, if You wish or need, ... : Art Talk, Integral Speech, 'Ola AH' Programming Language, Graphs, Mindful Imaging.


Assembler Optimization.

it's a low-level optimization.

it's done as that:
- many things can be done in many ways,
- every assembler mnemonic execution costs different amount of resources as processor cycles, registers, memory on various levels, ...
- often it's better to consider a many of possible options & select most optimal by given resources ... counting the costs as processor cycles & memory use in process,
- different processors have different parameters, the same operation costs different amount of resources ... has different electronics as blitter chip or a different amount of registers. optimal code for a given processor will use skilfully & wisely these features.

but let's remember that often it's better to write code in higher level programming language as C, then recompile for newer processor as it appears.

few of commands & we have a fairly optimal code for a new architecture.

low cost of operation & we have faster system thanks to newer hardware & higher level compiler.

we can use assembler inserts for bottlenecks still.

see also, if You wish or need, ... : Optimization Triad.

A Cloud Service.

in a context of this blog,

A Cloud Service is:
- Shared Service: possibly many services available on a shared infrastructure, at the same time for many of users,
- Service Available 24h/day,
- Fast & Secure Service.

still learning what it's truly, however.

... so this might change with time.


Clusters, like Grids are Distributed Systems.

Distributed Applications differ from Parallel Applications in that they are run on a many of computers, instead of in a single computer's memory.

what is a computer in this context?

basicly processor with memory.

while Grids are about task diversification at different computers, Clusters run the same application on each of computers for a service reliability & speed.

there's a Load Balancer software that queries Cluster parts for resources use, then dispatches a service requests according to it's strategy.

a strategy can send a request according to lightest load, or there can be priorities associated with IP address, or do something else.

load balancers can be replicated as well - for robustness, client can choose which load balancer to contact on his own.

clustered applications use the same database, often replicated as well.

database's copies are synchronized using Transactions.

see also, if You wish or need, ... : Kacper Cluster.

Worker Service Pool Grid.

Service Pool pattern.

it's idea in my mind since a while.

there are various sources, including Apache River & other.

we can have a naming/directory service that when asked for an utility service with interface name, answers with ip addresses, ports & other data describing available services.

we can choose which service suits best our needs, and connect with it.


Leader-Worker pattern.

it's also an idea in my mind since a while, it's realized in a Stitie Grid article, for example.

we have a worker service with a worker interface ... that accepts .class file(s) & object(s) then executes the code at worker machine without restarting computer or application.

after finishing it's work, worker machine(s) can send results to Leader machine.

during their work, worker machine(s) can communicate with other services including Leader machine.

worker can also be leader, by having sub-workers.


Worker Service Pool Grid pattern.

it's a combination of two above patterns,

we have a worker pool with addresses, we contact naming/directory service with interface name & get details on how to contact worker service(s),

we connect & send the code forming a grid,

execute code at worker machines.

when work is done, we release worker machines from service.

it's also called: 'Dynamic Grid Construction & Release'.

i can imagine that 'Dynamic Grid Construction & Release' has uses in a Cloud Services.


Grid as an Object Graph.

Grid can be seen as an Object Graph, each computer being an object with methods (available via ports at ip address) & state (data in computer memory).

Objects can communicate, talk with each other, do it's common task.

Object Graph can be seen as a model of a Program, can be run.


Reserve Components & Tiering.

in case of a component(s) failure(s), other reserve component(s) can be used.

component here is a Computer System plus application software that runs on it.

best if reserve components are a part of the Design, possibly Clusters.

but also they can be dynamically created, their Client can contact Leader in case of a non-answering Server for a new ip address & port of a reserve component - stateless application design allows for that, state can be transferred as well.

there's also a possibility of functionality tiering.

details: Conditional Software Tiering.


Service Leasing.

i think that way computing power can be leased for a time at a given price,

it's convenient that way in my opinion.


Unit Tests.

i think that Unit Tests should be added to Dragonfly Project's code.

avoiding to notice error does not make this error disappear.

it's like hiding head in sand, pretending there's no problem.

Unit Tests help to face reality better & help to detect code errors earlier.

there's little of work overhead with that methodology, but this time is regained later because there's less time spent on fixing errors.

it's easier to fix one error at time than two or more at once.

we can also sleep better, being more secure that code works correctly more often.

less delusions better sleep.

see also, if You wish or need, ... : Conditions, Security Harness, Software Complexity.

Quantum Energy Forms.

one of add-on features to Stitie Space 1.1 'Sunsail' will be energy forms modelling functionality.

will look for it's name later.

it will be just a few classes with code & examples to include (copy-paste will do fine) in Stitie Space's code.

it will include:
- Quantum model of Particle,
- Model or notation that describe Quantum Forms (shapes, but also their behavior) and name them (for MATEN invocation for example),
- Description & Notes for each of Quantum Forms,
- Rotation attributes for a Quantum Form at coordinates ... for OX, OY & OZ axis (with 0 poit at Form's Center), stored in a double precision floating point numbers,
- Translation before Rotation attributes for a Quantum Form at coordinates ... by X coord, by Y coord & by Z coord ... applies to a data within Form, stored in integer numbers,
- Translation after Rotation attributes for a Quantum Form at coordinates ... by X coord, by Y coord & by Z coord ... applies to a data within Form, stored in integer numbers,
- Intermediary Forms (that will use recursion & subforms, probably with MATEN Form Invocation),
- State implementation that will contain Forms with (inner, more fine-grained, precise) coordinates at given coordinates (outer, coarse, less detailed),
- State implementation will also contain a misc data space (probably Object array[15]), including a method call names for associated Strategies (probably String fields),
- Strategy will consist of three steps: before Particle Events handler (such as particle movement or collision), Particle Events handler, after Particle Events handler ... these will have access to State, including Forms & misc data to use as these need,
- Machine for modelling (one representing space, another one or more that will contain forms for a lookup),
- Sorting Forms by name, or by coordinates,
- Grouping coordinates to a Form (for duplicate Form representations),
- Perhaps Mindful Imaging Module that will visualize each of Spaces, including Intermediary Form Imager(s),
- Perhaps more.

Quantum Nature of Particles is probabilistic, if i remember well ... this means that we can have probability of a Particle occuring at given coords at given time.

when particles are at the same coordinates there's probability for collision at each moment in time.

when moving particles, perhaps there's mathematical model that will allow to move them in sequence (not at the same time) and have that included in calculations. moving a very many of ultra-small particles at the same time would require a very large amount of processor cores or processors.

will need to learn more about Quantum Physics, looking for this eagerly.

see also if You wish or need, ... : Particle Interactions on Quantum Level, perhaps more.