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


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.

Relationship Types.


Inheritance is an 'is-a' relation.

The UML graphical representation of a Generalization is a hollow triangle shape on the superclass end of the line (or tree of lines) that connects it to one or more subtypes.

The superclass (base class) in the generalization relationship is also known as the 'parent', superclass, base class, or base type.

The subtype in the specialization relationship is also known as the 'child', subclass, derived class, derived type, inheriting class, or inheriting type.

For example, 'an oak is a type of tree', 'an automobile is a type of vehicle'.


A realization relationship is a relationship between two model elements, in which one model element (the client) realizes (implements) the behavior that the other model element.

The UML graphical representation of a Realization is a hollow triangle shape on the interface end of the dashed line (or tree of lines) that connects it to one or more implementers. A plain arrow head is used on the interface end of the dashed line that connects it to its users.


A dependency is a semantic connection between dependent and independent model elements.

It exists between two elements if changes to the definition of one element (the server or target) may cause changes to the other (the client or source).

This association is uni-directional.


An association represents a family of links.


Aggregation is a variant of the 'has a' association relationship; aggregation is more specific than association. It is an association that represents a part-whole or part-of relationship.

Example: a Professor 'has a' class to teach.

Aggregation can occur when a class is a collection or container of other classes, but the contained classes do not have a strong lifecycle dependency on the container. The contents of the container still exist when the container is destroyed.

In UML, it is graphically represented as a hollow diamond shape on the containing class with a single line that connects it to the contained class.

Example: Library has Students and books. Here the student can exist without library, the relation between student and library is aggregation.


When attempting to represent real-world whole-part relationships, e.g. an engine is a part of a car.

The UML graphical representation of a composition relationship shows composition as a filled diamond shape on the containing class end of the lines that connect contained class(es) to the containing class.

Differences between Composition and Aggregation.

Aggregation relationship is often 'catalog' containment to distinguish it from composition's 'physical' containment.

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 & other UML parts.


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.

'Domain knowledge' is knowledge needed to write software that is not neccesarily the Computer Sciences-related.

Object Oriented Analysis & Design is a useful tool for understanding, transforming & modelling the Domain Knowledge, in order to create Software Design & Implementation.

Domain Knowledge is far more important than OOA tools, however, in my opinion at least.

OOA tools make it more efficient to obtain the Domain Knowledges, but on their own are not very practical.

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]. See also, if You wish: Object Oriented Analysis, Design & Modelling.


'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.

Stitie Machine in Ada.

Planning Ada Implementation of Stitie Machine 1.0 & 1.1.

(not just yet, this post will be edited if/when this happens).

Learning Ada is good Source of Experience in Concurrency & Language Security - this will be useful for 'Ola AH' Programming Language Semantics & Compiler Implementation.

Dragonfly Algorithm, not so Economical.

Why not Computer Science / Economy Tech?

i am not so Materialistic as IT Business.

Preferring Computer Science / Art / Mathematics / Physics / Psychology Technology which can Protect.

No BPM integration with Dragonfly Algorithm, unless Woman i Love asks me to do this for her. Or Buddha.


Concurrent Algorithms & PRAM.

Concurrent Algorithms.

As computers evolved into concurrent machines, concurrent algorithms were developed.

Concurrent Algorithms allow for more than one operation be executed at any given moment.

Concurrent Algorithms are tied to Concurrent Computation Models, such as PRAM (Parallel Random Access Machine).

Parallel Random Access Machine.

PRAM Basic Architecture.

PRAM Machine (Machine with PRAM Architecture) consits of:

- Shared Memory,
- n processors P0, P1, ... , Pn-1 connected to the same Shared Memory.

Shared Memory Speed.

How much time takes Shared Memory Access Operation?

Basicly the more of Processors competing, the more time they lose on accessing Shared Memory. Otherwise it's a constant time O(1).

Concurrent Algorithm's work time depends both on amount of data to be processed & on amount of Processors.

Memory Access Modes & Types of PRAM Machines.

We can say that there are four concurrent memory access modes:

- CR: Concurrent Read: more than one read at given moment from the same memory cell,
- ER: Exclusive Read: only one read at given moment from the same memory cell,
- CW: Concurrent Write: more than one write at given moment to the same memory cell,
- EW: Exclusive Write: only one write at given moment to the same memory cell.

We can say there are Concurrent Algorithms of Classes:


There are different PRAM machines that can handle different concurrent algorithms classes:

- EREW PRAM (simplest hardware solution, highest software writing costs),
- CRCW PRAM (most complex hardware solution, lowest software writing costs).

CRCW PRAM can handle EREW Concurrent Algorithms, but EREW PRAM can't handle directly CRCW Concurrent Algorithms.

Without additional assumptions, when multiple Processors write to the CRCW machine at the same moment, it's not determined what will be written.

In common-CRCW model, if multiple Processors write the same value to the same memory cell, they must write the same value.


PRAM Machines are fully synchronized - no Processor will execute two instructions until all Processors finalize their current instructions.

See also: [4], Distributed Shared Memory.

Computing Nets.

Like Comparing Nets, the Computing Nets use devices to transform input into output.

While Comparing Nets use Comparators, Computing Nets are more generic.

Computing Nets use Transformers, which transform input sequences into output sequences.

When joined by wires, these transformers form Computing Nets.

For example we can have Transformer which can compute f1(x,y) = x + y for (x,y) of given domain, or another transformer which can multiply f2(x,y) = x · y for (x,y) of given domain.

Simple function transformers let complex functions be efficiently computed, with enough of Transformers connected by wires properly.

Stitie Space can be used to model such Computing Nets.

See also: Stitie Machine 1.1 'Sunsail', Comparing Net.

Sorting Nets.

Comparing Net with n = 4, that is also Sorting Net.

Sorting Net with n = 8, relying on insertionsort algorithm.

Sorting Net is Comparing Net in which output sequence is sorted for every input sequence.

See also: [4], Comparing Net.


Comparing Net.

Concurrent algorithms use concurrent computation models.

One of such is Comparing Net, which has two qualities:

  1. Can perform only compare operations,
  2. Can perform many operations concurrently.

Comparing nets are made of wires & comparators only.


Comparator is a device with two inputs: x, y and with two outputs: x', y' that count following function:

  x' = min(x,y)
  y' = max(x,y)

Let's assume that each of comparators works in constant time O(1). That is, time between appearance of all input data and production of output is constant.

Comparator image using wires.

Comparing Net has n inputs: a1, a2, ..., an where values to be sorted are put, and n outputs: b1, b2, ..., bn where sorted values appear.

We can also say that we have input sequence: < a1, a2, ..., an > and output sequence: < b1, b2, ..., bn >.

Comparing Net with n inputs can be shown as n horizontal lines, wires with comparators. Single line does not have to represent one wire but sequence of wires that connect many comparators. Input data is on the left, output to the right.

Comparing Net with n = 4, that is also Sorting Net.

Source: [4], Sorting Nets.

Robot Swarm.

Had insight, that P2P Robot Cloud Control System should operate not on nanoscale but with robots of size of 1 mm3. ('milimetrites', not 'nanites').

It can have ability to reform, not by melting like a poodle of water, but by dispersing & reforming in air, then reconnecting again.

Each of robots has to be flying - for example in magnetic field, communicating wirelessly - for example with xaser communication in magnetic field if possible, and needs ability to connect with others in any way - for example, magnetically. That's the precondition.

It can for example form a Communication Device - for example a Communication Ray that can move & reform as neccessary, and has use for example in a Cave where corridors are not straight - if we do not want to broadcast message in all directions.


Kyton Form Demo.

Kyton Devil can be modelled in Stitie Space (which is Object Matrix), and Visualized.

He can be animated, sending and waving command chains and this can be Visualized too, along with how objects change colors & perhaps positions as affected by Kyton's Chains. (with an upgrade of Mindful Imaging).

This can look like Martial Art even.

This Form can be Invoked in Computer Memory using MATEN or Prism Functionality.

More skillful is using Prism to transform Stitie Space to invoke Kyton Form properly.

See also: Kyton Bindings.

Kyton Bindings.

Kyton is Chain-Devil, an Artistic Metaphor.

Devils are very lawful & evil beings, very disciplined, strict & malicious, as the Science can be.

Kyton Chains are not easily broken however...


Property synchronization occurs when a change in one of objects causes a change in other bound object, to reflect that change.

Objects are to be 'bound' before such synchronization can occur, in an act called 'Property Binding'.


Kyton Bindings should be property binding functionality that is reliable, strict & secure.

This can be done using event system, for example in Stitie Space. In reaction to an event of a change in an object we can send a message that will cause change in other object, synchronizing them. In Stitie Space, message should be sent in Command Chain.

This is strict & mostly reliable design, for security there's need for more work.


In case of Stitie Space, security work would include:

- No errors in all of Software Components, passing of all tests, perhaps even Proof of Correctness,
- Minimal amount of Code & Optimal Low-Level Structure (preferably in Assembler, perhaps C),
- Use of trusted & secure Operating System or code directly to 'bare metal',
- Proper use of Cryptography,
- Robust & Reliable mechanism of finding bound objects in Stitie Space,
- Runtime security checks & other known security mechanisms inclusion (Ada Programming Language would be example of source of Inspiration for such),
- Hacking support.

this is LOT of effort to ensure this Level of Security.

much less secure mechanism but still fairly useful would include:

- No errors in all of Software Components, passing of all tests,
- Minimal amount of Code,
- Use of trusted & secure Operating System,
- Proper use of Cryptography,
- Robust & Reliable mechanism of finding bound objects in Stitie Space,
- Runtime security checks & other known security mechanisms inclusion (Ada Programming Language would be example of source of Inspiration for such),
- Critical Vulnerability patching,
- Hacking support.

still LOT of effort.

i think that Stitie Machine / Stitie Space should be ported to Ada for Security, Concurrency & Speed perhaps - this cuts costs of Secure & Efficient solutions using Stitie Machine / Stitie Space, as i guess.


Equations Matrix.

if we consider following equations set (1), written informally as:

a1,1x1 + a1,2x2 + ... + a1,nxn = b1
a2,1x1 + a2,2x2 + ... + a2,nxn = b2


am,1x1 + am,2x2 + ... + am,nxn = bm

we can say:

- it is set of m linear equations with n unknown values.
- numbers ai,j ∈ K we call coefficients of that set,
- bi are free values,
- xj are unknown values.

let's use following notation:

- A = (ai,j) ∈ Km,n,
- vector b = (bi) ∈ Km,
- vector x = (xj) ∈ Kn.

then equation set (1) we can write as Matrix Equation:

A ∗ x = b.

Source: [1].

See also: Matrix (over body K).


Elementary Net Systems Introduction.

Basic System Description.

in Elementary Net Systems, a net represents the underlying static structure of a distributed system with:

- S-Elements representing conditions (local states),
- T-Elements representing events (local actions, transitions),
- F representing neighbourhood relations (flow). F ⊆ (S x T) ∪ (T x S).

case is: 'conditions holding concurrently',
step is: 'events occuring concurrently'.

(to be continued, perhaps).

See also: [6], Petri Nets.

Introduction to Cooperating Processes & Synchronization.


Process is a running program.

Independent & Cooperating Processes.

Processes can be either independent or cooperating.

Processes are independent if they are not affecting each other.

Processes are cooperating if they can affect each other by sharing data - either temporary or persistent.

How data can be shared?

Data can be shared in many ways.

For example:

- via Shared Memory,
- via Queue,
- by sending a Inter-Process Communication Message (IPC Message).
- via a file written on a pendrive.

Process synchronization.

It's important to synchronize timing of read/write operations done by processes - so the data is not read before being written, for example.

For example: perhaps we do not want to check amount of money in our bank account before it arrives on that account then make automated decision based on that amount.

Concurrent Programming is that part of Computer Sciences that explains how to synchronize Processes.

Why split tasks among multiple processes?

- to share data among multiple users or to use the same data for different tasks.
- to speed up the computation, for example to allow for effective use of multiprocessor or multicore machines.
- code quality, modularity. single responsibility per process so they can be reused and combined together.
- practical reasons, for example: so we can type data at the same time as music is played and partial computations are done.

See also: [7], [12], Petri Nets, Distributed Shared Memory.


Theory of Computation.


In theoretical computer science and mathematics, the theory of computation is the branch that deals with how efficiently problems can be solved on a model of computation, using an algorithm.

i think that Philosophy, Ideas, Innovations & Solutions are also part of Computational Theory - they are part of models or algorithms.

Models of Computation.

In computability theory and computational complexity theory, a model of computation is the definition of the set of allowable operations used in computation and their respective costs.

Models of Computation include:

- Finite State Automatons,
- Stack Machines,
- Turing Machines,
- perhaps more.

Three major branches of Theory of Computation.

- Automata theory.

Automata theory is the study of abstract machines (or more appropriately, abstract 'mathematical' machines or systems) and the computational problems that can be solved using these machines.

These abstract machines are called automata.

Stitie Machine is example of such.

- Computability theory.

Computability theory deals primarily with the question of the extent to which a problem is solvable on a computer.

- Computational complexity theory.

Complexity theory considers not only whether a problem can be solved at all on a computer, but also how efficiently the problem can be solved.

Two major aspects are considered: time complexity and space complexity, which are respectively how many steps does it take to perform a computation, and how much memory is required to perform that computation.

Not all problems can be solved in 'sane' amount of time using 'sane' amount of resources such as memory or printer paper.


i should start at some point measuring costs of operations of a Stitie Machine & Stitie Space models, as well as try to prove their correctness, checking stop conditions in process.

this will happen with time, if i can.

then should consider problems & algorithms compatibility with these models.

See also: [7], [4], [19], Stitie Machine (Maszyna Stanikowa Wysockiego), perhaps more.

Conditional Instruction & Expressions.

Conditional Instruction 'if' consists of:

1. Conditional expression that evaluates to a boolean value (truth or falsehood).

for example: ( o.getA() > 0 ) might be an expression that evaluates to boolean value.
for example: o.containsData() might be expression that evaluates to boolean value.
for example: ( o != null && o.containsData() && o.getA() > 0 ) might be expression that evaluates to boolean value.

2. Instruction to execute in case of truth.

for example: return; // a valueless return statement.
for example: { } // empty instruction.
for example: doSomething(); // function call.
for example { doSomething(1); doSomething(); } // complex instruction consisting of two function calls, with similar function signatures.

3. Syntax.

syntax is method of writing.

syntax can be varied depending on Programming Language, but has to be unambiguous.

for example: if (a = 0) then doSomething();
for example: if (a == 0) { doSomething(); }
for example: if ( (a == 0) iff (b > 3) ) { doSomethingUseful() }

See also: Logical Operators, How computers 'think', or conditional instruction 'if' explained, Lazy evaluation.


Logical Operators.


Logical operator wording is such:

A - word A, might be true or false.
B - word B, might be true or false.

not - logical negation.
and - logical conjunction.
or - logical alternative.
xor - logical exclusive alternative.
=> - logical implication. can be written as IMP.
<= - logical implication in reverse direction. can be written as IREV.
<=> - logical operator 'if and only if', also can be written as IFF, XNOR or often as ==.
nand - logical operator 'not and'.

Boolean Algebra basics.

Boolean Algebra basics using logical operators, A, and B:

A B not A A and B A or B A xor B A imp B A irev B A iff B A nand B
true true false true true false true true true false
true false false false true true false true false true
false true true false true true true false false true
false false true false false false true true true true

for example if we have: A is true, B is false, then we can say that alternative (A or B) evaluates to truth, thus has truth value. we can also say that this alternative is true.

Boolean Expressions.

Boolean expressions are equations that use words, parentheses & logical operators, equations that evaluate to boolean value.

for example: (A imp B) would be a boolean expression, a function whose value depends on values of words from set: { A, B } which can have boolean values contained in a Boolean Value Set: { true, false }.

for example: ((A or B) iff C) would be a boolean expression, a function whose value depends on values of words from set: { A, B, C } which can have boolean values contained in a Boolean Value Set: { true, false }.

'iff' differs from '==' operator with type safety. 'iff' accepts only boolean values, where '==' might also compare integers, for example. '==' might compare boolean values as well, but not only. both can be used with expressions that evaluate to boolean values.

De Morgan's Laws.

In boolean algebra De Morgan's laws are a pair of transformation rules that are both valid rules of inference. The rules allow the expression of conjunctions and alternatives purely in terms of each other via negation, with use of parentheses for operator priority.

1. 'A and B' is the same as 'not ( (not A) or (not B) )'
2. 'A or B' is the same as 'not ( (not A) and (not B) )'

De Morgan's Laws are also used in Set Theory, perhaps elsewhere as well.

See also: Conditional Instruction & Expressions.