Programmer's 6 - Tiered path to Victory.


i'll share & elaborate if / as i am ready, perhaps rearranging.

(work in progress for as long as neccessary).


Path to Victory:

1. 'Know the Code, Know the Bug'.

the most ambitious of programmer's ways, in my opinion.

an apex of the programmer's ability but can be practiced even by beginners.

... if they dare.

basicly, You have the code, You have the bug (something wrong, an error) to fix, fix it.

anything permitted, learn and / or hack if neccessary.

all of consequences still hold.

... the main bug is Your Ego.

2. 'Know the Problem, Know the Code'.

take responsibility, but strictly adhere to standard programming methods, no 'politics', no 'foul play' etc.

understand 'the problem to solve', understand 'the code'.

plan 'solution' including tiers 3 - 6.

implement and / or debug 'the code' if neccessary.

3. 'Know the Risk, Know Your Way'.

list (write) all of the risks You can, discussing / brainstorming with Your team as well.

try to solve most risky (dangerous) problems at first, perhaps by writing software prototype.

if solution is too inefficient or costly, do not hesistate to cancel 'the whole' of a project.

proceed with tier 4 as well.

4. 'Know the Cost, Know the Time'.

it's basicly all of the simpler solutions (tiers 5 & 6).

try to include the cost (budget, perhaps more) & time limit in planning.

try to learn how to assess how much the tasks will take You to complete them, even if it's almost impossible to do this properly.

it's safe to give Yourself / Your team extra time to reduce stress.

5. 'Know the Problem, Know the Way'.

at this tier, You can start to learn as You have spare time.

otherwise it's tier 6, do not experiment too much but when You are sure, propose solutions.

6. 'Know the Team, Know the Way'.

know who's the boss, know who is responsible for what in your team, follow orders strictly while helping the team as You can.

See also, if You wish: 6 - Tiered path to Victory.


Tactical Programmers.

i think that 'tactical programmers' - programmers who employ problem solving tactics are more efficient at doing their work, and should earn more.

this struggle costs them sanity.

See also: Know Yourself, Know Enemy, Know the Code, Know Enemy?.

'Know the Code, Know the Bug'.



Military tactics are the science and art of organizing a military force, and the techniques for combining and using weapons and military units to engage and defeat an enemy in battle.

In contemporary military science tactics are the lowest of three planning levels:

(i) strategic,
(ii) operational,
(iii) tactical.

The highest level of planning is strategy, how force is translated into political objectives, by bridging the means and ends of war.

The intermediate level, operational level, the conversion of strategy into tactics deals with formations of units.

In the vernacular, tactical decisions are those made to achieve the greatest, immediate value, and strategic decisions are those made to achieve the greatest, overall value, irrespective of the immediate results of a tactical decision.

Source: Wikipedia.


Orders Encoding.

First we enumerate units - give names to each of units.

Alpha - forces leading attack,
Beta - forces securing Alpha Team,
Delta - forces guarding back.

Alpha-Alpha - alpha unit of alpha unit (subgroup).

Then we enumerate orders - give aliases to each of possible orders (serialize).

attack - 1,
hold position - 2,
secure - 3/unit.

then we can say for example: (alpha-1; alpha-beta-2), beta-3/alpha, delta-2.

most specific suborders have priority.

this means:

1. alpha unit attacks, except for beta group of alpha forces which holds position.
2. beta unit secures alpha unit (all orders hold according to their priority, in this case unit secures alpha forces as it was prepared before).
3. delta unit holds position.

then we can encrypt this information & send.

for example, as this can be elaborated as anyone wishes.

i think this can be combined with objects selection in Stitie Space (see: Stitie Machine 1.1 'Sunsail'), and perhaps can be part of 'Ola AH' Programming Language 's semantics & syntax... will experiment with Stitie Machine 1.2 'Satellite' if/when i can.

Taunt Tactic.

it's about making opponent to attack our forces.

it's moving enough of proper forces to a certain position to pose a danger to opponent's positionality or important units.

this move can be elaborated into an ambush lure or if opponent won't react - into positional victory, probably more.


Fast - Start Tactics.

it's about starting fast with small force while bolstering (improving) defenses.

then we retreat to protected location, luring opponents into an ambush.

it's useful when opponent has more offensive forces, and we have better defenses.

to reduce numbers before their forces start to be real threat (reinforcements, alliances etc).



a Form of Energy & Light.

Electric Charge.

Basic component of Electricity is Electric Charge.

Electric charge in normal state of physical body is neutral. In isolators this state can be changed, for example by rubbing.

Electric charges affect each other with force (for example, when two rods of acrylic glass or ebonite are near each other).

Charges with the same polarity are repelling each other, while charges with the opposite polarity are drawing each other near.

Electric charge is measured in ampere-seconds (A·s) also called Coulombs (C).

Electric charge depends on amount of electrons orbiting around nucleus, as well as on amount of protons in nucleus.

More electrons make for negative polarity, more protons for positive polarity.

Atom with non-zero charge is called 'ion'.

Elementary charge, minimal amount of charge in electron or proton is either:
-1,602 x 10-19 C, or +1,602 x 10-19 C respectively.


Between opposite polarity charges there's force of attraction.

If needed to separate charges, work is neccessary against forces of attraction.

Work becomes stored as potential energy, between charges voltage is made.

There's inclination for charges to neutralize themselves, so electric voltage is also inclined to neutralize itself as well.

Electric voltage is force put to separate charges, in comparison to charge's magnitude.

Electric voltage (symbol: U) is measured by voltmeter.

Unit of voltage is volt, which has symbol of V.

[U] = 1V (read: unit of voltage is volt).

Voltage can be considered as the electric pressure. If two metallic bodies with opposite charges are connected by a conductor, electrons move caused by the voltage from negative electrode to the positive electrode.

Voltage relative to certain point, for example on ground is called 'potential'. Voltage can be presented as difference between two potentials.


Presence of voltage causes electric current flow.

Electric current can flow only in closed circuit.

Electric circuit consist of source, destination & wires (in any form) connecting source to destination.

Electric circuit can be opened or closed with electric switch.

Electric Circuit.

Materials contain electrons, which may move freely within material. These electrons are called 'free electrons'.

Free electrons move from places where there are too many electrons to places where is not enough of electrons.

In proper conductors, for example: in copper or silver, there are almost as many free electrons as there are electrons moving on atoms' external orbits.

Directed electrons flow we call: 'electric current'.

There's force in electric current, that affects free electrons. That force affects whole electric circuit after it's closed.

Electrons move affected by that force.

Direction of the electric current is opposite to the electrons flow & equal to the flow of positive ions in fluids.

Electric current affects surroundings in various ways.

Heat & magnetism occurs all the time. Light, chemical affects, living organisms affects occur only in certain conditions.

Electric current (symbol I) is measured with ammeter.

Unit of current's intensity is ampere (A).

- Direct Current (DC) - direction of electrons flow is constant, from negative pole to positive pole,
- Alternating Current (AC) - direction of electrons flow alternates constantly,
- Universal Current (UC) - consists both of AC & DC.

Difference betweeen Amperage & Voltage.

Amperage, or current, is a measure of the amount of electrons moving in a circuit.

Voltage is a measure of how much force those electrons are under.

Source: [28], [41], the Internet.

See also, if You wish: Atomic Structure (proceed with caution), Electric Resistance, Introduction to Physics, Fields & Units.

Array List - Theory & ANSI C Implementation.

List can be implemented as a resizable array.

it's data structure L with operations:
- insert(L, index, value) - inserts 'value' element on list L, after element at position 'index',
- get(L, index) - returns 'value' element on list L, at position 'index',
- delete(L, index) - deletes element on list L, after element at position 'index',
- size(L) - returns number of elements on list L.

after 'insert' or 'delete' operation, list is reorganized & perhaps resized (to twice of it's previous size, by default).

we can see that 'insert' & 'delete' operations are expensive, but 'get' cheap - opposite to Pointer Lists (LinkedLists in Java), which have fairly cheap insertion, but it's expensive to get element from selected position.

(to be continued as soon as possible).

Source: my partial education, my programming experience.

Hash Map - Theory & ANSI C Implementation.

What is Hash Map?

Hash Map is dictionary data structure.

Hash Map assigns values vn to keys kn from key set. Each of keys must be unique.

Hash Map has at minimum, following operations:
- search(kn) - returns vn assigned to kn,
- insert(kn, vn) - inserts (kn, vn) pair into hash map data structure properly, keeping association between key kn & value vn.
- delete(kn) - deletes (kn, vn) pair from hash map.

Often however, it also has following convenience operations:
- get_keys() - returns set of keys k1...km,
- size() - returns amount of elements in key set,
- perhaps more.

'Hash' part of 'Hash Map' name comes from 'hash function'.

Hash function usually helps (there's no guarantee for speed) to quickly find place where key is or should be located.


Key set can be implemented using array list of keys, with hash function we probably won't have to search through whole array list for a key.

(to be continued as soon as possible).

Source: [4], [19], [30], my partial education, my programming experience.


Simple Parser Tutorial.

What this post is about?

it's a simple example of how context-free grammar parsers can be designed & implemented.

it's fairly advanced topic, requires knowledge of programming, programming languages, regular expressions & related.

perhaps it's too few words, please contact me if You wish something elaborated.


our parser will accept texts written in language with:

1. integer numbers & boolean values.
2. arithmetic operations on integer numbers:
- addition,
- substraction,
- multiplication,
- division.
3. arithmetic operations on boolean values:
- not,
- and,
- or.
4. expressions & grouping operations (parentheses).
5. variables & assignment instruction.
6. conditional instruction if.
7. input & print instructions.

this should enable for basic arithmetic/logic operations whose results can be printed on screen.

they are mandatory for any serious programming language in my opinion, input & print instructions as well - even if they are only standard library functions.

Context-Free Grammar.

first we'll design language's grammar, which consists of productions, terminal symbols, nonterminal symbols & separators written in a serie of code lines.

* token -> instruction | expression
* instruction -> conditional_instruction | assignment_instruction | variable_declaration | input_instruction | print_instruction
* conditional_instruction -> if ( boolean_expression) instruction;
* assignment_instruction -> identifier = expression;
* variable_declaration -> variable_type identifier;
* variable_type -> int | boolean
* print_instruction -> print identifier;
* expression -> number_expression | boolean_expression | ( expression ) | input_instruction
* number_expression -> number | ( number_expression ) | -number_expression | number_expression + number_expression | number_expression - number_expression | number_expression * number_expression | number_expression / number_expression
* boolean_expression -> boolean_value | ( boolean_expression ) | not boolean_expression | boolean_expression or boolean_expression | boolean_expression and boolean_expression

in this language we do not allow for conversion between types, for simplicity.

what is an identifier, number, boolean_value etc... we'll define a little later, during tokenization process. terminal symbols of grammar will be defined there, as well as other things.


(to be continued, if/when i can).

See also: Context-Free Grammars, Simple compiler design.

Stitie Machine 1.3 'November Rain'.

1.3 'November Rain' version of Stitie Machine is open for ideas.

Features considered for this or later version:
- Space, Transformations & Recursion; i think something more or less related to ideas presented in this article can be included in future versions, probably later than 1.3 - i need to finish Mathematics Masters Degree first, understand mathematics better, include ideas learned, refine, improve & elaborate design & concepts as well.

Distributed Operating Systems.


Distributed Operating System allows hiding & protecting resources at servers.

Resources & Services.

Distributed Operating System provides mechanisms needed to reach for these resources, such as:

- naming,
- communication,
- planning.

resources include:

- non-software files, including:
  - information,
  - art,
- software, including:
  - information management,
  - internet galleries,
  - physical device controllers,
- perhaps more.


resources are hidden, stored & protected at server(s).

for resource to be available, client must know:
- server's IP address at which the resource is,
- as well as port.
(if we use the Internet solution).

it's convenient to use simple names for resources however, without caring for remembering resource's current location.

then we can say:
- let's get report file #108.
- let's switch mode of our transport car #84000 to 'delivery'.
- let's get art file called 'mona lisa #27'.
or something similar. (identifier does not have to be a number).

'Naming Service' can help us hide resource location under a name, by resolving identifier to address:port combination.

for example:
'mona lisa #27' ->
'report file #108' ->
'delivery car #84000 mode controller' ->

naming service can work like DNS tree for example, as it's simple approach.

naming service should be reconfigurable, allowing to change resource's location as resource moves between servers without extra effort from user(s).

Source: [13], my partial education, my experience & insights, Wikipedia.

See also: 'Literature & the Internet' section, mostly [13] & [12].

i think that Stitie Space has potential to serve as software infrastructure for coordinating and/or modelling remote services.


'Ola AH' as a 4GL Programming Language.

- what is 4GL Programming Language?
- i think that 4GL (Fourth Generation Language) is programming language that allows for faster software development than 3GL (Thrid Generation Language).

- can 'Ola AH' be 4GL class of Programming Languages?
- i think yes, due to Stitie Space, a part of 'Ola AH' semantics. it's a data structure in which an objects graph filled with code - a program - can be modelled & run.

- are there additional costs of using 4GL?
- i am not sure if programs written in 4GL (or at least programs written in 'Ola AH') are slower ('Ola AH' is not created yet, but i have ideas & imagination). i think it will take user a while to get used to new tools. perhaps more.

- how such faster development can be realized?
- with better syntax, graphical/textual - with modelling objects graph & filling parts with code, that together will create a running program model, with proper GUI (Graphical User Interface).

- why it's faster?
- less code writing, less mouse clicks, better program overview, perhaps more.

- should graphical/textual syntax unambiguously translate to 'text-only syntax'?
- definitely yes, i think. to elegant text even.


what else is there to consider?

- perhaps in future, when computing resources allow for that, systems can be modelled on a pixel-by-pixel basis, then parts or even whole filled with code.

- perhaps class diagrams & other software design models will be possible to create in 'Ola AH' Programming Language's toolset - these should be easy to map on the software during the design & development software construction stages, along with their names & version number. this should unify tools for analysis, design & programming into one internally-coherent solution.

- perhaps unit & integration tests, as well as profiling & debugging will benefit from visual-objects-graph design & overview. should be named & versioned as well. another step into internally-coherent, practical & unified solution for all of the iterative-software-construction stages.

See also, if You wish or need, ... : Esoteric Programming Languages, Funges & Ola AH Programming Language, Token Game.


Attacking Combined Threats.

How to attack combined threat?

We need:

1. Means (optimal tool, more or less) to attack threat A.
2. Means (optimal tool, more or less) to attack threat B.
3. Means (optimal tool, more or less) to attack their combination (hybrid weapon, or combined forces of two factions, for example).

First we attack combination of threats, to separate, thus breaking their 'bone'.

When one of threats (A or B) gains in strength, we have means to attack that threat separately.

LightPoint as an Object.

LightPoint is a part of Stitie Machine 1.1 'Sunsail'.

LightPoint is (State, Strategy) pair, which is equivalent to an Object as in Object Oriented Programming - under condition that Strategy has access to a State.

In Stitie Machine 1.1.34-RC-0-0-3 'Sunsail', there's LightPointObject class that can be used this way:

final Certificate cert = new Certificate();

// test #1 : without 'superclass'.
final LightPointObject lpo = new LightPointObject(new HashMapStateImpl(), null);
lpo.addMethod(cert, "add", new Strategy() {
  public void execute(Certificate cert) {
    Integer[] args = (Integer[]) lpo.getArgs(cert);
    int result = args[0] + args[1];
    lpo.setReturnValue(cert, result);
  public int getPriority(Certificate cert) {
    return 0;

lpo.addMethod(cert, "sub", new Strategy() {
  public void execute(Certificate cert) {
    Integer[] args = (Integer[]) lpo.getArgs(cert);
    int result = args[0] - args[1];
    lpo.setReturnValue(cert, result);
  public int getPriority(Certificate cert) {
  return 0;

lpo.setArgs(cert, new Integer[] {3,2});
System.out.println("test #1: without superclass.");

lpo.setMethodToCall(cert, "add");
int result = (int) lpo.getReturnValue(cert);
System.out.println("add operation call's result: " + result);

lpo.setMethodToCall(cert, "sub");
result = (int) lpo.getReturnValue(cert);
System.out.println("sub operation call's result: " + result);

// test #2: with superclass

LightPointObject lpoSubclass = new LightPointObject(new HashMapStateImpl(), lpo);
lpoSubclass.addMethod(cert, "sub", new Strategy() {
  public void execute(Certificate cert) {
    lpoSubclass.setReturnValue(cert, 0);
    // weird value - used only for testing of method inheritance & polymorphism
  public int getPriority(Certificate cert) {
    return 0;

LightPointObject lpoSubclass2 = new LightPointObject(new HashMapStateImpl(), lpo);
lpoSubclass2.addMethod(cert, "add", new Strategy() {
  public void execute(Certificate cert) {
    lpoSubclass2.setReturnValue(cert, 20);
    // weird value - used only for testing of method inheritance & polymorphism
  public int getPriority(Certificate cert) {
    return 0;

lpoSubclass2.addMethod(cert, "sub", new Strategy() {
  public void execute(Certificate cert) {
    lpoSubclass2.setReturnValue(cert, 10);
    // weird value - used only for testing of method inheritance & polymorphism
  public int getPriority(Certificate cert) {
    return 0;

System.out.println("test #2: with 'superclass'.");

lpoSubclass.setArgs(cert, new Integer[] {3,2});
lpoSubclass2.setArgs(cert, new Integer[] {3,2});

// testing calling method from superclass. (subclass has it not defined).
lpoSubclass.setMethodToCall(cert, "add");
result = (int) lpoSubclass.getReturnValue(cert);
System.out.println("add operation call's result: " + result);

// testing method overriding & polymorphism.
lpoSubclass.setMethodToCall(cert, "sub");
result = (int) lpoSubclass.getReturnValue(cert);
System.out.println("sub operation call's result: " + result);

// testing calling method from superclass. (subclass has it defined).
lpoSubclass2.setMethodToCall(cert, "add");
result = (int) lpoSubclass2.getReturnValue(cert);
System.out.println("add operation call's result: " + result);

// testing method overriding & polymorphism.
lpoSubclass2.setMethodToCall(cert, "sub");
result = (int) lpoSubclass2.getReturnValue(cert);
System.out.println("sub operation call's result: " + result);

// in real programming, unlike what's shown in this exercise,
// separate superclass object copy should be made for each of subclass objects,
// to prevent 'state overlapping' & state overwriting.


more details - in the code.

See also: Stitie Machine 1.1 'Sunsail'.

What is a Function?

in Mathematics:

Let X,Y be any nonempty sets.

X is called function's domain, Y is called function's codomain.

def. function is assignment for each element in X an exactly one element in Y.

in Computer Sciences:

functions take n-arguments, which can be represented as one object (tuple), then assign returned value to this tuple of values.

all possible values of n-argument tuple are domain of a function, all possible returned values are codomain of a function.

if function's value also depends on other factors such as global variables, these factors can be assumed to be part of input of n-arguments.

- are Computer Sciences part of Mathematics?
- i think yes.

Function notations.

1. Mathematical formula.

y = x2, for x∈ {-2, -1, 0, 1, 2, 3, 4}.

2. Words.

There are sets X = { -2, -1, 0, 1, 2, 3, 4 }, Y = { 0, 1, 4, 9, 16 }. Then for each number from set X we assign a square of that a number.

3. Table.


4. Graph.

5. Ordered pairs set.

{(-2,4), (-1,1), (0,0), (1,1), (2,4), (3,9), (4,16)}.

see also, if You wish: Gardener's Functions.

in the above example of 'a function of the garden', pairs are: (coordinates, object).

6. Graph.

7. Computer program code.

int square(int x) {
  if (inDomain(x) == false) { throw new RuntimeException("x = " + x + " not in domain"); };
  return x * x;

boolean inDomain(int x) {
  return ((x >= -2) && (x <= 4));

i think that 'Ola AH' programming language should have following syntax features:
- elegant domain clauses (because of function domains in Mathematics & functional programming paradigm, because of invariants & contract, perhaps more),
- optional 'function' keyword before function's signature line,
- multiple argument tuples both in return values, as well as in passed arguments.

code would look like:

function int square(int x) {
  cd x inX; // cd is short for 'check domain'
  return x * x;

dc inX(int x) { // dc is short for 'domain check'
  return ((x >= -2) && (x <= 4));

another example:

function (int, int) myFunc (int x0, int x1) {
  cd x0 inX; // cd is short for 'check domain'
  cd x1 inX;
  return (x0 * x1, -(x1 * x1));

Function equality.

Two functions f and g are equal when and only when their domains are equal, and when for the same arguments they are assigned equal values.

(to be elaborated, perhaps).

Source: [42], my partial education (unfinished MIM UW), my programming experience.


Internet of Things, the Distributed Machine.

i think that this type of robots (distributed machines) is to be expected in future.

a swarm of flying small units cooperating, moving in formations, perhaps shooting or carrying different orders.

'internet of things' on small or other scale(s).

See also: Stitie Machine 1.1 'Sunsail', Nanite War Computer Game,
Checking Field & Tactics, How to defeat modern machine?, Tactical Forms & Formations in 3D.


Genetic Algorithms.


i am not Expert in Artificial Intelligence Field of Computer Sciences, but i try to guess after reading Wikipedia.

Use (or not) at Your own risk.

Critic is welcome & asked for.


In the computer science field of artificial intelligence, a genetic algorithm (GA) is method of finding optimal solutions.

Candidate Solutions.

In a genetic algorithm, a population of candidate solutions (called individuals, creatures, or phenotypes) to an optimization problem is evolved toward better solutions.

Each candidate solution has a set of properties (its chromosomes or genotype) which can be mutated and altered.

Candidate solutions, whether code parts or mathematical functions or other, might be represented as objects with properties (which can be objects as well).

Selection & Evolution.

The evolution usually starts from a population of randomly generated individuals, and is an iterative process, with the population in each iteration called a generation.

In each generation, the 'fitness' of every individual in the population is evaluated by a function.

The more fit individuals are selected from the current population, and each individual's genome is modified (recombined and possibly randomly mutated) to form a new generation.

It is worth tuning parameters such as the mutation probability, crossover probability and population size to find reasonable settings for the problem class being worked on. A very small mutation rate may lead to genetic drift. A recombination rate that is too high may lead to premature convergence of the genetic algorithm. A mutation rate that is too high may lead to loss of good solutions, unless elitist selection is employed.


This generational process is repeated until a termination condition has been reached.

Common terminating conditions are:

- A solution is found that satisfies minimum criteria,
- Fixed number of generations reached,
- Allocated budget (computation time/money) reached,
- The highest ranking solution's fitness is reaching or has reached a plateau such that successive iterations no longer produce better results,
- Manual inspection,
- Combinations of the above.

Source: Wikipedia.

See Also: Neural Networks, Stitie Space.

Basics of Concurrent Programming.

Concurrent work is multiple works happening at the same time.

Process is a running program.

Thread (lightweigh process, LWP) is object inside heavyweight process that has it's own control & that shares resources with other threads in the same process.

Critical section is a code section that can be accessed by only one process or thread at the same time.

critical section has uses for example in banking: we do not want data to be overwritten as it's written by other process, or read during writing.

example pseudocode:

process P;

  while true do

Source: my partial education (see: [7]), my experience.

See also: Petersen's Algorithm, Classic Concurrency Problems, Petri Nets.


Checking Field & Tactics.

Idea comes from game of Chess.

'Checking Field' spans among fields, and is capability to remove opponent's units if they move to position covered by 'Checking Field'.

If we cover opponent's escape with 'Checking Field', then move our unit(s) on attack position... then we can remove that unit from playing field.

i think this has use in Tactics.

Related topics, to be elaborated perhaps:

- Positional Chess,
- 'Sacrificing units' to remove 'Positionality'.
- Escort Field.


Software Costs & Optimization.


Every program instruction costs a set amount of processor time, and there is also memory cost for running program.

Sometimes we can talk of other costs such as printer paper pages used or HDD space taken.

Program running costs depend on algorithm used.

Costs usually depend on amount of data processed, that can be measured by proper mathematical function.

There can be optimistic costs, average costs, pessimistic costs.


Time is usually measured in algorithmic steps, amount of most 'expensive' operations done by algorithm.

Memory used by algorithm is usually measured by amount of memory cells used.

Costs can be precise: for example average_processor_time_cost(n) = n3 + 17 steps, average_memory_cost(n) = 0.5 · n2 + 3 memory cells.

Costs can also be written in asymptotic notation O(n).

O(f(n)) means that f(n) is an approximate value limited by upper asymptote for n ≥ n0 where n0 is a constant.

for example, classic sorting algorithm might have asymptotic time cost of O(n · log(n)), and parallel sorting algorithm might have asymptotic time cost of O(log2 n).


Computer Program can be optimized to perform better in certain area at cost of other areas, other things as well.

For example, there can be memory optimization if we recalculate partial results at each algorithmic steps to not store them in memory.

For example, there can be speed optimization if we use memory cache to store data retrieved from HDD and take it from cache if it's available before trying to read from HDD. That way most often read data will be available in memory cache and we won't need to read it from HDD, as it is slow operation.

For example, there can be programmer time cost optimization if we sacrifice quality of software to finish software sooner (programmers are usually paid per hours of work). That type of optimization leads to increased software production & maintenance costs soon after, i should add.

Programmer's time saved - for example thanks to object orientation - can be used for other types of optimization, i should add as well.

Source: My partial education, [4].

See also, if You wish: Optimization Triad.

Wave Interference.

Wave Interference, a Light - double slit experiment.

interference is commonly encountered when two waves of the same wavelength are added together.

Wave Interference, as in Mathematics.

we see that if the two waves are in step (the technical term is 'in phase') they add together to produce a combined wave that has twice the amplitude.

if, on the other hand, they are exactly out of step (in 'antiphase') they cancel each other out.

result of waves interference with a phase difference & the same wavelength is a wave with a different phase & amplitude but with the same wavelength.

Wave Interference, with a Phase Difference.

the phase difference is δ = π/2 or 90 degrees.

the two waves interfere, with the resulting wave (blue) equal to the sum of these two waves.

Wave Interference, Water.

Source: [28], the Internet.



NEMS - nanoelectromechanical systems - are devices integrating electrical and mechanical functionality on the nano scale.

Nanoscale is objects of size: 1 nm -> 100 nm.

1 nanometer: 1nm = 10-9 m (one billionth of meter).

See also, if You wish: Nanotechnology, 'Ola AH' Programming Language for Nanotech ?



Object Address Space.

Stitie Processor Memory Model, with volatile memory parts in each of Stitie Machines can be used to fairly efficiently serve classical Object-Oriented Paradigm needs.

Stitie Machines at each of coordinates can serve as memory cells, each for one object that is saved in State object. If contained object is too large, stitie machine can reference external memory as well.

Thus, 'Ola AH' Programming Language should allow for classic Object-Oriented Programming, beside it's features.


Introduction to Physics, Fields & Units.

Purpose of this blog post.

Electronic Phenomena can be described by terms of Physics.


If there's influence from distance, we can say that between the cause of influence & affected body there's Field.

A physical field can be thought of as the assignment of a physical quantity at each point of space and time. For example, in a weather forecast, the wind velocity during a day over a country is described by assigning a vector to each point in space. Each vector represents the direction of the movement of air at that point. As the day progresses, the directions in which the vectors point change as the directions of the wind change.

So a Field can be described by n-dimensional Mathematical function, for example: assignment of a scalar or vector to n-dimensional coordinates (time can also be a coordinate).

If affected bodies are influenced by Force, we can speak of Force Fields.

There are many Fields, including Gravitational Field of Earth, Electric Fields, Magnetic Fields.

Electric & Magnetic Fields are tied, forming Electromagnetic Fields that are changing with time.

Radio-TV Sattelites can receive or radiate Electromagnetic Fields into Space, for example.

Field Intensity.

Field Intensity is the vector sum of all forces exerted by a field on a unit mass, unit charge, unit magnetic pole, etc., at a given point within the field.


Almost every physical quantity has it's unit - either basic or derived.

QualityQuantity SymbolUnitUnit Symbol
electric current intensityIamperA
light source intensity, brightnessIvcandelacd

Basic Physical Quantities.

QuantityBasic unitsParticular unit nameSymbol
ampere-secondA · scoulombC
per second1 / shertzHz
square meterm · m-m2
Forcekg · m/s2NewtonN
workN · mJouleJ

Derived Units.

Acceleration & Force.

Applying force, we can accelerate movement of a body, change it's speed.

Change of speed (Δ v) divided by amount of time during which that change occured (Δ t), we can call 'acceleration' (a).

a = Δ v / Δ t.

The more acceleration (a) near given mass (m) the stronger force affecting that mass.

Force is a vector (quantity with direction). We can say: vector F, or write it as: F.

F = m · a.

Speed & Velocity.

Speed & velocity are differing in that velocity is a vector (quantity with direction), whereas speed is quantity without direction.

Velocity (v) is length of the way (s) travelled in a given time (t).

v = s / t.

Velocity is measured in meters per second (m/s).


Work (w) is force (F) times length of way (s).

w = F · s.

Work is a vector.

When force (F) & way (s) are not on the same straight line, a component of force vector (Fs) that is along way is used in calculations of work (w).

w = Fs · s.


Energy is capability to do a work. Work causes change in energy quantity.

Energy cannot be created, but it can be transformed into another form (for example: chemical energy can be transformed to heat energy during burning process, solar or nuclear energy can be changed to electricity).

Potential energy is energy contained in certain system, for example in physical body mass in gravitational field of Earth.

Potential energy at initial position has value equal to work neccessary to move mass from initial position to new position.

wp = Fc · Δh.

w - potential energy.
Fc - gravitational force.
Δh - difference in position (height).

Potential energy can also be stored in other ways.

Kinetic energy is contained in physical body mass that is moving.

Kinetic energy depends only on mass & velocity.

wk = 0.5 · m · v2.

Source: [41], Wikipedia, perhaps more.

Memory Swapping.

Using more of memory, as well as using faster memory can prevent computers' instability & slowness to great extent.

To be able to run a computer program, Operating System must load it into memory first (into Processor's Cache or RAM).

Running program is called a 'Process'.

What if computer memory runs out, for example: due to loading too much of data?

There's an option of using slower memory that is cheaper & loading extra data or processess as neccessary into fast memory.

For example:

1. Few processes in RAM (Random Access Memory), rest waiting to be loaded in HDD Storage or DVD-ROM.
2. A process in Cache, rest of processes in RAM & HDD Storage.
3. In case of Stitie Space, part of Stitie Machine's State & keys in fast memory, rest in slower. Strategy in either, but during code's execution - in fast memory, at least it's part.

Let's note that Memory such as Cache is closer to Processor & faster than RAM, but more expensive - therefore we can buy it less for our money. It has to be used wisely, for example for most critical & most often used parts of software.

Similarly RAM is faster & more expensive than HDD Storage.

Registers, Cache, RAM, HDD Storage & similar can form a 'Pyramid of Needs', with more rare types of memory used more sparingly, due to costs.

Smaller processes run faster - we do not need to worry too much about loading parts of the process & data, then swapping the rest as needed. In case of Cache, with execution code & data being closer to processor, requests do not need to go via Serial Bus - and that speeds computing significiantly. Similar mechanism can be observed between accessibility of RAM & HDD Storage.

Also, there are algorithms that can take advantage of extra memory to use it for faster programs' execution (for example, by storing partial results for different data sets then using them later without computing again).

With more of processes running at once there's need to do more of swapping between faster & slower memory which costs time, same with amount of data increasing.

Extreme case of swapping abuse (for example: by loading too many programs at once into memory) can halt the computer almost to zero speed or even cause Operating System to crash.... if swapping requires more effort than is used to compute processes' data.

Sources: my partial education (see [7]), 12.


Current State of Stitie Processor Idea.

As for now it looks like:

- cubes containing objects connected as in stitie cube,
- on hardware level, 'infrastructure hardware & code' packed in between cubes,
- external memory available, single memory array that can act as a Stack if neccessary,
- each of objects can reference external memory, 'as they please'.

this is CPU + Memory extension.

perhaps will provide image as an example, a little later if i can.


Secure Terminal Device.

One of ideas that appeared in Mind was to create Secure Communication Terminal Device with Dedicated Software, with 3D Graphics.

Dragonfly Algorithm tech's focus is 3D Graphics & Security & the Internet.

To succeed in designing such Device, need to involve Physics, Electronics, probably more.

At least at basic level - to be able to talk efficiently with Experts.

As far as timing goes for this project, aiming for when there are cheap multi-core processors on market (about 4096 cores) & when 1 TB of RAM is available & cheap. Will need persistent memory, touch-screen display & USB as well. Network interface might be internal or external (USB-connected). This project might delay and happen after when these preconditions are met.

See also: Stitie Machine 1.1 'Sunsail'.


Modern & cheap RD9700 USB Network Interface.

Useful when built-in Network Interface breaks or fails for example.


Algorithmic Overscalability.

Overscalability is quality of a parallel algorithm to scale speed faster than we add processors, when compared to best known sequential algorithm.

For example: when conditions are met (when data list is numerous enough) sorting nets can sort data much faster than classic sequential algorithms and meet requirements of overscalability.

Sorting nets can sort data in time of O(log2 n) using n processors.

Classic sequential algorithms can sort data in time of O(n · log n).


Sorting Nets.

Sorting Net sorts a sequence of comparable elements in a time of O(log2 n), where n is number of elements in that sequence.

Sorting Net can be a Parallel Tool & Algorithm that requires n processing units to be effective - a pair of processing units can form a comparator.

There can be more effective solutions as well, for example processing unit with many programmable comparators at it's disposal. Programmable with a 'compare' operation.

Sorting Net Construction Algorithm.
Sorter is Sorting Net, this is recurrential construction.

Sorting Net Construction with expanded recursion, for n = 8.

Sorting Net example, for n = 8.

See also: Merger.

Source: [4].


Design for Volatile Parallel RAM Server for Objects.

This design is about Volatile Parallel Random Access Memory server in Java Programming Language.

Stored data is lost when service goes down.

Memory can be represented in computer memory as an sequentially indexed array.

Communication can happen via standard socket interface with use of fast queues for each of cells & for infrastructure services such as returning memory size & cell size.

Size of a memory cell can be configured before service's start, and byte sequences can be stored or retrieved from a cell with given address.

Objects can be stored in memory, if there's space available for them, otherwise an error is reported.

First objects are marshalled (serialized) to a byte sequence, then stored in server's memory - including the data neccessary for unmarshalling. This happens as atomic operation, and can happen in more than one memory cell. Java Reflection API should be used. Marshalling / Unmarshalling of Objects should happen at Client, not on Server, but there should be also a server for 'stored objects map' and accessing stored objects should happen through it as atomic operation.

See also: Concurrent Algorithms & PRAM.



Merger is a tool for merging two sorted sequences of the same length & of comparable data type(-s), into one sorted sequence.

For example: < 2, 3, 4 > can be merged with < 3, 5, 7 > into < 2, 3, 3, 4, 5, 7 >.

Merger uses Bitonic Sorter & part comparing i-th element with n - i + 1 for i = 1, 2, ..., n/2.

Merger Construction Algorithm, for n = 8.

Merger Example, for n = 8.

Merger has use in Parallel Sorting Algorithm with time complexity of O(log2 n).

See also: Bitonic Sorting Net.

Source: [4].


The Internet Search Engine for Anti-Terror.

How to make an Internet Search Engine?

Easiest way is to just write an application that visits web pages either at random, following clues or in an ordered pattern, or using a mix of these.

After visiting a page, it's contents can be downloaded for analysis & categorization.

This process needs to be repeated after a given time period, to check if web page content changed, and needs to be re-categorized.

This takes resources such as computer memory, cpu-cycles, the Internet bandwidth, is race against time... but even without large amount of resources, parts of the Internet can be visited still, and it's cheaper if we know what we are looking for.

Then downloaded & categorized data can be presented to users, who write 'queries' in search field and get results of the search in response - picked from data that has been prepared for them in previous steps.

Sorting Server, Parallel or not, can be useful for preparing large amounts of data for categorization, presentation, perhaps for more.

Various the Internet Search Engines can serve different purposes, depending on which, methods of search, categorization & presentation can vary.

To write a Search Engine that seeks Terrorist Threats in the Internet, application writer needs to understand Terrorism - it's language, thinking patterns, methods of communication & symbolism, perhaps more. He or She needs to be prepared to handle that properly as well. This is what i lack at, at least for now.

Knowledge of Cryptography helps too.

Parallel Sort Server.

i think that Stitie Space can be used to model Sorting Net or it's parts as neccessary.

When combined with Database, really large amount of data can be processed in parts, then combined into whole Sorted Data Structure.

Cost would be O(log2 n) plus cost of modelling & instantiating Sorting Nets which are more or less O(m2), where m is size of data parts to be processed, m ≤ n.

Because of multiple threads use, multiple processors or cores are used efficiently (will have to check / correct code if neccessary, once have Highly Parallel Machine to work with).

Specificially looking for Highly Parallel ARM Processors with Java Bytecode support.

See also: [4], Stitie Machine 1.1 'Sunsail' for Stitie Space, Advanced RISC Machines (ARM) & Java, perhaps more.


Advanced RISC Machines (ARM) & Java.

'ARM is a family of instruction set architectures for computer processors based on a reduced instruction set computing (RISC) architecture developed by British company ARM Holdings.

A RISC-based computer design approach means ARM processors require significantly fewer transistors than typical CISC x86 processors in most personal computers. This approach reduces costs, heat and power use. These are desirable traits for light, portable, battery-powered devices—​including smartphones, laptops, tablet and notepad computers, and other embedded systems.

A simpler design facilitates more efficient multi-core CPUs and higher core counts at lower cost, providing improved energy efficiency for servers.

ARM Holdings develops the instruction set and architecture for ARM-based products, but does not manufacture products. The company periodically releases updates to its cores. Current cores from ARM Holdings support a 32-bit address space and 32-bit arithmetic; the ARMv8-A architecture, announced in October 2011, adds support for a 64-bit address space and 64-bit arithmetic. Instructions for ARM Holdings' cores have 32 bits wide fixed-length instructions, but later versions of the architecture also support a variable-length instruction set that provides both 32 and 16 bits wide instructions for improved code density.

Some cores can also provide hardware execution of Java bytecodes.'

Source: Wikipedia.

Forces Classification.

in context of this blog:

- Task Forces: forces that are prepared to perform certain tasks.
- Supporting Forces: forces that are prepared for supporting other Forces in their tasks.
- Repelling Forces: forces that are prepared to repel attacks (make opposing forces retreat or stop attacking in any way).

(perhaps more to come later).

examples in hacking warfare:

- Rootkit installers (Task Forces),
- DoS projectors (Supporting Forces),
- Remote Firewall installers (Repelling Forces).

there can be combinations of forces composition, for example:

- Task / Support Forces are prepared to perform their Tasks or to Support other Forces in their tasks.


Bitonic Sorting Net.

Sorting network for bitonic sequences can be constructed from 'half-cleaners'.


For size n input sequence, i-th input is connected with comparator with i + n/2 input,
for i = 1, 2, ... , n/2. We'll assume than n is even.


Bitonic Sorter.

Bitonic Sorter Construction Algorithm.

Using a Half-Cleaner & two smaller Bitonic Sorters we can Create a larger Bitonic Sorter recurrentially as shown on above image.

a Complete Bitonic Sorter Example.

Bitonic Sorting has use in Sorting with time complexity of O(log2 n) - a 'good behavior' for parallel sorting algorithms.

For Sequential Sorting Algorithms, 'good behavior' is time complexity of O(n · log n).

Source: [4], Wikipedia.

See also: Sorting Nets, Comparing Net, Bitonic Sequence, Bitonic Sorting in Cryptography.

Parallel PRAM Algorithm: List Ranking.

There are many ways we can rank list elements & there are many algorithms that enable us to do so.

List Rank of a List Element is it's distance from end of the List.

Classic sequential Algorithm works in time of O(n).

Quoted parallel algorithm for PRAM EREW machine works in O(log n) time on n processors.

Work done is measured as amount of processors times it's time efficiency, or O(n · log n), so there's cost for that speed.

Algorithm proceeds as follows:

List-Rank (pseudocode):

1. For each processor i in parallel
2.   do if (next[i]) = NIL
3.     then d[i] := 0
4.     else d[i] := 1

5. while exists object i such as, that next[i] != NIL
6.   do for each processor i in parallel
7.     do if next[i] != NIL
8.       then d[i] := d[i] + d[next[i]]
9.         next[i] := next[next[i]] // list's integrity is 'broken'

Algorithm's proceedings:

Pointers are destroyed in process of an algorithm execution, but they can be restored easily if we have copies of them (copy of proper pointer in each of list elements, for example), in constant time.

There are many similar algorithms and many tree algorithms that can be transofrmed to this class of algorithms (jumping algorithms).

Source: [4].

See also: Concurrent Algorithms & PRAM.


Forces Equivalence.

in context of this blog:

Force consists of units.

If we have more units of a given type than enemy we can attempt to equivalize (amount of) enemy units by preparing/arming equal amount of units with weapons meant to counter that force, and have rest of forces use mixed weapons, partly against that type of units, partly against other target(-s).

That way we have countering force with equivalent firepower and more supporting force(-s).

Countering units are specialized fully against given target.

Support units are not specialized fully against given target.

How easily unit defeats another (% of engagements succesfull) in a given conditions can be called efficiency against an unit in a given conditions.

If we have units that can defeat n of units of a given type 'easily' (efficiency of at least 90% of engagements), we can counter enemy force of m units with m/n units of such type of our own.

That way we can reach 'countering equivalence' against given force with m/n units of given type.

Efficiency of at least 90% we can call 'countering'.

Efficiency of more than 50% we can call 'superior'.

Efficiency of 50% we can call 'equivalent'.

Efficiency of less than 50% we can call 'inferior'.

Efficiency of less than 10% we call 'neglible'.

If we do not have countering efficiency, we can combine multiple units into a force and statistically assess their efficiency against the given target.

See also: Hacking firepower and operatibility.


Attack Vector.

in context of this blog:

An Attack Vector is:
- means of Attack (unit type for example),
- origin point of an Attack,
- destination point of an Attack.

there are other meanings as well, even in context of this blog.

Tactical Forms & Formations in 3D.

Optimal Distance from an enemy unit(s) is the distance at which we have maximum advantage and enemy unit(s) have maximum disadvantage.

In three dimensions, such as in a Stitie Space Model, to have certain unit(s) of the same type engage other unit(s) at optimal distance requires use of Certain Formations...

Form is idea, that gives qualities. Formation is spread of units in space.

Transition between such Certain Formations can happen in steps, and can be realized with MATEN Certain Form Invocation or with Prism Transformation as neccessary.

Optimal transition can consider many factors, such as keeping distance from certain unit(s) or points in space, or quickness of transition between Formations (amount of steps).

Formation (positions or at least coordinates of units in space) can be described by a function, complex or not.

Position is coordinates plus direction.

(to be finished if neccessary).

See also: Stitie Machine 1.1 'Sunsail' for Stitie Space, MATEN & Prism, Robot Swarm, Internet of Things, the Distributed Machine.


Object Relationships Modelling & Analysis.

In Context of Object Oriented Analysis (OOA):

Objects & Relationships.

The real world things that participate in relationship must be abstracted as objects.

Every relationship in the model is given a pair of names that describe the relationship from the perspective of each of the participating objects.

Object Relationship Object
Dog Owner cares for Dog
Dog is in care of Dog Owner

Types of Object Relationships.

'Unconditional' relationships.

Unconditional forms of relationship are called so because every instance of both objects is required to participate in relationship.

1-1 relationship.

A one-to-one relationship exists when a single instance of an object is associated with a single instance of another object.

1-to-many relationship.

A one-to-many relationship exists when a single instance of an object is associated with one or more instances of another, and each instance of the second object is associated with just one instance of the first.

many-to-many relationship.

A many-to-many relationship exists when a single instance of an obect is associated with one or more instances of another, and each instance of the second object is associated with one or more instances of the first.

'Conditional' forms & Cardinality.

In a conditional relationship there can be instances of objects that not participate. Relationship can be conditional on either side, or on both sides (biconditional relationship).

Cardinality of a side of relation is number of instances of objects on that side of that relation.

Cardinality options are: 1, 0..1, 0..n, 1..n, n.

Cardinality can be noted on either or on both sides of a relationship model.

Cardinality & Arrow Notation should not be a condtradiction.

If they are contradicting each other then model is erroneous.

Object Attributes.

a 'Home' object with four attributes named appropriately.

An attribute is an abstraction of a single characteristic possessed by all entities that were abstracted as objects.

This abstraction can be named & put in an object.

When implemented and run as a part of a program, each of attributes has a Data Type & a Concrete Value that can change during object's life.

Types of Attributes:

- Descriptive Attributes: provide facts intrisinc to each instance of the object.
- Naming Attributes: identifiers, instance labels.
- Referential Attributes: used to tie an instance of one object to an instance of another.

Relationship Objects.

Relationships can be modelled as objects, and have attribute(-s).

Contrary to opinion of many, either 1-to-1, either 1-to-many, or many-to-many relationship can be separated from objects participating in relationship and modelled as an object with attributes.

in case of 1-1 relation:

for example: where to put 'marriage contract' attribute?

- in 'wife' object?
- in 'husband' object?
- in both?
- or associate it with 'marriage relation' object that is associated both with husband and wife?

putting 'marriage contract' in both objects would cause data redundancy and possibility for inconsistent data; of course 'marriage relation' object should be Secured appriopriately.

in case of 1-to-many relation:

for example: a 'dog, dog-owner' relation, relations can be modelled as objects as well.

each pair: (dog, dog owner) is associated with relation object that applies to this pair.

in theory only part of dogs owned by an owner might be health-insured, others: 'not yet'.

in case of many-to-many relation:

for example: a 'house, house owner' relation, relations can be modelled as objects as well.

each pair: (house, house owner) is associated with relation object that applies to this pair.

in theory a house might have multiple owners, and any/each of owners might own multiple houses.

Ownership relation attributes: Address, Unit at address - can be references to Home.
Ownership relation attribute: Owner name - can be reference to Home Owner.

Graphical Representation of a Model.

There are many graphical notations, for example: Shlaer-Mellor, UML, ...

Above images were based on Shlaer-Mellor representation, enriched with Cardinality which comes from UML as 'far' as i know.


Model is the Basic Tool for Analysis.

Model can be examined, analysed & modified to simplify & abstract, then whole system can be reimplemented if needed or neccessary.

Source: [34], [36], insight.

See also, if You wish: A Quick Method for Mid-High Complexity Software Design, How to create software model using 3D Art model?, 'Talking Objects' Solutions, Object Oriented Analysis, Design & Modelling.


P2P Security.

Known attacks include:

1. 'Network Poisoning' by 'Malicious Nodes'.

Malicious Node on the Application Layer might give incorrect responses to requests & behave not according to protocol. This might mean much if money is transferred, for example. Peer-to-Peer Network Poisoning is about providing inaccurate data to other clients (peers in role of a client) and/or Process Coordinator (if there's any), to manipulate whole Network or just do harm to the Infrastructure or to Trust of the System.

2. Attacks on individual network nodes.

Software Modifications & Attempt for Unauthorized Network Join might result in 'planting' a malicious node(s) in the system.

Organizations should be wary of the software distribution, whom they give source or binary program code and/or keys - software and/or hardware keys, i think.

Hacking might result in taking over, modification and/or reconfiguration of existing network nodes in the system.

3. Exploiting software issues (assuming that software does it's job correctly, and is not malicious):

- Vulnerability to buffer overflows & similar hacking methods,
- Authentication & Authorization Issues - keeping passwords & keys secure, keeping ciphers unbroken, keeping certificates valid,
- Message Confidentiality, Message Integrity & Message Nonrepudation Issues - we wish to know who sent us message, if he sent, be sure if it wasn't tampered with in process, or captured & examined,
- Attacks on Ciphers & Cryptographic Attacks on Messages, for example in preparation for Man-in-the-Middle Attacks,
- User Privacy Attacks - attempts to gain unauthorized information from Network Peers - this can be used in preparation for more damaging attacks, for example,
- Trust & Cerficiation Issues - for example not all users agree to use the same Certification Authority (CA) or combinations of such,
- Accountability Issues (Users should know that they are & be responisble for resources used, including accountability for costs of using system resources),

4. Attacks on whole network.

- If node(s) behave not according to protocol, whole system might fail due to Security Issues. There's risk for Damaged Trust, for system Failing somehow, for Financial Loss, for Data being stolen, in preparation for more damaging attacks.

5. Social Engineering Attacks.

- Psychological Manipulation, including Artful Symbols Use in the Internet, with goal of making an employee open 'a message attachment' that runs trojan horses or other malicious software,
- Terrorism, Seduction & other Attacks on Personnel.
- Phone Calls,
- Stealing passwords.

6. Viruses, of all kinds.

7. Exploiting other software components vulnerabilities.

8. Attacks on Network & Infrastructure.

- Denial of Service,
- Physical Hardware Security.

9. Perhaps more (there are many pages to read, with example systems & their vulnerabilities, might take a while).

See also: [7], [8], [14], [17], [26], [37], [38], One time codes, ciphers and online security., Cryptographic Attacks., Weakest Link., perhaps more.


Remote Packet Sniffer.

i think that Remote Packet Sniffing can be realized using:

1. with Graph of 'Proxy Servers', standalone or hidden parts in other Internet Applications,
2. with ARP Redirect functionality being part of above 'Proxy Servers'.

See also: ARP redirect attack (for computer enthusiasts), Password Sniffing.

Application Engine & Interface.

Applications can be constructed from more or less independent parts.

For example we can have computational engine which counts something, manages data, etc. ...

That Engine Part is independent from rest of components.

Then we can add Interface Part, an intermediate between Engine & User.

The Interface accepts input, for example: mouse clicks, text or numbers typed, and more... to pass such to Engine, then after receiving results present to the User properly.

There can be different Interface Views* of Engine's Data, transformed or not... which together form Graphic User Interface (GUI).

In one interface view we can look at data and see for example: details of person's Art preferences to present it to the User. in another interface view, for example we can sort user names alphabetically or other way... and present in form of a table on monitor's screen.

Because we have separated idea of data (model) from idea of graphic user interface view (GUI view) one team can develop engine part not worrying about how it's presented... while another team is responsible for GUI. Work is faster that way, as more people can be easily involved without teams interfering each other too much. Little of communication between teams is still required however.

In Computer Sciences there's even a Design Pattern known as Model/View/Controller (MVC)... but many people disagree how it works in certain situations.

* There are multiple meanings to word 'View' in Computer Sciences.

Traceroute Implementation.

This article is about implementation design & issues, later there will be source code as well, perhaps.

To determine the route in the Internet that the packets go through, we can send message(-s) with TTL (Time to Live) field set to 1 then increase it by 1 until packets reach their destination.

That way we'll receive ICMP messages 'Time to live exceeded' from each of routers on the packet's way.

Traceroute program does just that, as 'far' as i know.

If we have 'proxy servers' on the way, we can be more sure that the data is not falsified.

This can be expensive however.

Source: [3], [5], [7], perhaps more.


Web Services Simplified.

i think that a Web Service can be seen as an object, that communicates with other web service objects via Network, such as the Internet.

these web service objects can depend on interfaces instead of implementation, and use remote objects as implementations.

an object registry can be used to query & locate web service implementation we want to use in the Internet, and to establish connection with such.

known standard for such registry is UDDI, for communication with remote objects it's SOAP.

that way we can construct a running program, a process, a graph of collaborating objects from partial solutions in the Internet.

See also: SOA and Web Services.

Design Patterns.

In software engineering, a Design Pattern is a general reusable solution to a commonly occurring problem within a given context in software design.

A design pattern is not a finished design that can be transformed directly into source or machine code.

It is a description or template for how to solve a problem that can be used in many different situations.

Stitie Machine & related use 'Strategy', 'State', 'Event' Design Patterns, perhaps more.


A socket is a software interface for sending or receiving messages via Network such as the Internet.

Processes can use sockets for communication, directly in computer memory or via Network such as the Internet.

See also: [3], Wikipedia.


Code Reuse.

High Quality program code should be split into Reusable Components that can be shared and/or sold.

For following reasons:

- speed of creation & modification: if we buy part of code, we can use it instead of creating from scratch - this saves time if done well,
- lower costs for higher quality: programmers who specialize generally have better price/quality ratio in their field, when compared to other competitors... let's not forget however that it's natural human desire to improve and broaden horizons,
- trust & robustness: when software parts come from known source, they have chance to be trusted & tested enough to not fail too often. they might have also well-documented characteristics - including contracts perhaps,
- efficiency: reusable components should be optimized, with data structures & algorithms selected properly. if they are optimized not the way we prefer, we can change implementation - that is, exchange software part for different,
- integrity: reusable software coming from the same source often conform to coding standards of that source, thus is compatible with rest... as it should.
- sharing & sales: components can be shared with others, to help... or sold. this helps whole team.

in my opinion every program class is a reusable component. even if it 'has' other reusable components as it's parts.

i think that 'Ola AH' Programming Language & it's Distribution Infrastructure should support sharing / sale of reusable components.

See also: [27], SOLID.


Protocols have uses in inter-process communications, they allow processes to cooperate and to perform tasks as a group.

Protocols consist of:

- Ordering of messages to be exchanged,
- Message formats,
- Acions taken on the transmission and/or receipt of a message or other event.

Ordered messages with precised data formats are similar to method calls, parametrized or not.

Protocols can be modelled as a Tree, with message leading from one processes state to another, depending on data passed. Process state change can result in sending more of messages - to one or more of processes. Or messages can be sent periodically, their type, timing, amount & targets depending on state.

Source: [3], [13].

See also if You wish or need ... : Conversation State.



There's - primitive & simplistic for now - application for Encryption / Decryption.

Perhaps with time more complex Cryptographic Methods will be added.

GWT Source code is not available, for now at least.



Counting & Probablitity.

Sets can be expressed as Sum(-s) of Disjoint Sets or as Cartesian Products.


Amount of possibilities of selecting element from one of two disjoint Sets equals sum of Cardinalities of these Sets.

Cardinality of a Set is number of elements in that Set.

|A ∪ B| = |A| + |B|.


Amount of possibilities of selecting ordered pair equals to amount of possibilities of selecting first element multiplied by amount of possibilities of selecting second element.

|A × B| = |A| · |B|.


An n-length word over finite set (alphabet) S is a sequence of n S-set elements, with or without elements repetition.

for example:

we have S = { 0, 1 }, n = 3.

there are 8 binary words of length 3:

000, 001, 010, 011, 100, 101, 110, 111.


Permutation of a finite set S is ordered sequence of all S-set elements, with each of elements occuring only once.

for example:

for S = { a, b, c }

we have 6 permutations: abc, acb, bac, bca, cab, cba.

amount of pemutations of n-element set Sn equals n! .

perm_count(Sn) = |Sn|! = n! .


k-combination of n-element set S is a k-element subset of set S.

for example: if we have S = { a, b, c, d }, k = 2, then we have six 2-combinations of S:

{ a, b }, { a, c }, { a, d } , { b, c }, { b, d }, { c, d }.

number of k-combinations of n-element set S equals:

 =  (
)  = 
k!·(n - k)!


def. Event Space S is a Set with Elementary Events.

def. Possible Outcome H, of experiment, H ⊂ S, 0 ≤ |H| ≤ |S|.

def. Elementary Event E is possible outcome of an experiment, E ⊂ S, 0 ≤ |E| ≤ 1.

def. Probability P(H, S) = |H| / |S|.

See also: [4], [7].


OOA Domains.

in Object Oriented Analysis, a domain is:

def. A domain is a separate real, hypothetical, or abstract world inhabited by a distinct set of objects that behave according to rules and policies characteristic of the domain.


my intuition would be that a domain is a 'world' with its ideas (forms).

i've also learned that, like in Mathematics, domain is a set, finite or infinite, with rules that determine which objects are in domain, and which are not.


examples of such domains with objects, or worlds with ideas:

1. Railroad Management.
- train,
- schedule,
- freight car.

2. Screen Management.
- window,
- scroll bar.

3. Process Input/Output.
- sensor,
- actuator,
- ADC,
- binary input field.

4. Operating System.
- task,
- message,
- mailbox,
- event flag.

together they are part of Software to support Railroad Management.

Source: [34].


'Ola AH' Programming Language.

'Ola AH' Programming Language will be a new way of programming computers, a tool to give certain companies advantage over competition, has it's reasons detailed in the following article.

It's intended to be both practical & esoteric, optionally visuospatial language.

'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, but most likely a compiler for classic PCs' will be made anyway as well.

This is summary of 'Ola AH' characteristics:

O means Wisdom, no matter what ignorants say.
LA means 'Highest'.

AH is the Mantra for Speech.
AH is also: 'Anti-Hack'.

'Ola' is also a name of a Buddhist Woman i Love, in a way at least... for she's student of Lama Ole Nydahl, i think ...

Does 'Ole' mean 'Highest Wisdom in Male Form' ?

- Object Oriented.
- High-Level / Low-Level.
- Nicely Concurrent (inspiration: Java Locks, Conditions & 'synchronized' critical sections, Abstracted Petri Nets & a 'Token Game', perhaps will be used. Linda is realized in a form of Stitie Space as well. Linda is defined as 'tuple space', according to my partial Uni MIMUW education.). Nicety is about resources lease & sharing, such as processor cycles ... we run on lower priority (as with 'nice' linux command) & save resources for others within our time constraints as far as our nicety priority allows. then we can claim back in times of need. it's a form of a processor cycle loans. it should be a part of 'Ola AH' Programming Language Semantics. 'Ola AH' Nice Concurrency can be managed using extra 'leader machine' with a Stitie Space.
- Semantics (meaning) & Syntax under development still.
- Initial version's semantics should include Stitie Machine 1.2 'Satellite' & Stitie Space; later Stitie Space's versions probably will be added to future versions of 'Ola AH' Programming Language,
- There should be easy mode & harder modes, including 'Anti-Hack' mode, which should enable low-level programming mechanisms with a 'different grammar' & a 'different instructions set' and/or lower security mechanisms to let them be customized by an Expert Programmer.
- With the 'Console Debugger' functionality - programs will be possible to be executed in the 'debugger' mode, that is controlled with interactive console; instructions can be dynamically added, inserted, removed, examined, modified during the runtime; with 'breakpoints' & 'forwarding' functionalities, 'stacktraces' & 'instruction lists' examination as well ... perhaps more in future as well; 'console debugger' will be configurable (with instructions) before the program's run, then program during execution will be modifiable as well (with interpreter instructions commands).
- With the 'Console Profiler' functionality - complete logging, statistics & configurable reports of methods execution time, as well as reports of how many times a certain method was called during program's run; as an extension of method time logging etc ... there should be analysis of code blocks defined by 'profiler <label> start' & 'profiler <label> end' points; memory use profiling should be considered as well; perhaps other resources use (in abstract form?) as well.
- With time 'Ola AH' Programming Language should be more Mathematical, Physical, Artful, Psychological etc.
- With time 'Ola AH' programs should be compiled to executable files, even if at first 'Ola AH' should be Interpreted Language only.
- Perhaps it'll be 4GL.
- Perhaps it'll be AI-augmented in future (Artificial Intelligence can aid in application creation, modification, debugging & refinement, and after an app is done - in it's administration, configuration & management as well).

Inspiring Languages:

- Pascal,
- Ansi C,
- Assembler,
- Java,
- Smalltalk,
- Ada,
- Google Go,
- perhaps Haskell as well,
- perhaps POV-Ray as well.

a rough estimate of time to complete the first 'Ola AH' compiler would be: 15 - 20 years. this might change.

a rough estimate of time to complete the first 'Ola AH' interpreter in Java is by 1.1.2022. if time allows, it will also compile 'Ola AH' code to the Java bytecode.

Main 'use cases' for 'Ola AH' Programming Language are mentioned in: 'Ola AH', Niche Language,

With 'Ola AH', every high-level instruction or standard library method, will be modelled & documented properly. There will be an object model of a running program that can be inspected with reflection & debugging. There will be 'asm insert' operation modelled as well. The 'asm insert' will contain a collection of assembler instructions, inspectable as well. Instructions object model, instructions semantics, instructions syntax - will all be a part of language's official documentation.

See also, if You wish: Object Address Space, What is a Function?, Conditional Instruction & Expressions, Simple compiler design, Type, State, Context, Object & Class, Paradigms & Programming Languages, Tuple Data Type & Syntax, Tuple, Set, Entity, Object, State, When Ola AH will be Practical ?, 'Ada', 'Linda' & 'Ola AH', Programming Languages, Agile Transformation of Information State, Modelling Speech Forms, 'Ola AH' Programming Language for Nanotech ?, 'Ola AH' Programming Language Randezvous System, Petri Nets, Petri Nets & Randezvous Concurrency, an Idiom, 'Ola AH' Security Semantics & Syntax, 'Ola AH' & Functional LightPoint Objects Forming, 'Ola AH' Programming Language & Quantum Computing, Stitie Space, Form & Emptiness, Esoteric Programming Languages, Funges & Ola AH Programming Language, Memory, Cache, Processor Use & 'Ola AH' Programming Language.