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


Heavy Weapon advantage.

Why to invest in heavy clusters?

Because if we ignore scale, our enemies can arm themselves with heavy clusters well tailored (specialized) to attack small computers ignoring heavier threats.

If we have heavy cluster, they have to consider scaled threat and attack them as well.

In other words... heavy weapon changes front, raising costs of attack on our infrastructure.

Hell Factor in context of hacking.

in context of hacking:

def. Hell Factor is threats accumulated. it can be measured by function. if it's beyond tolerance threshold it's better to retreat (for example by uninstalling rootkit) or hide (for example by quietening processes or stopping communications).


Hacking firepower and operatibility.

In context of hacking:

def. firepower depends on amount of units and quality of software used to perform tasks.

def. operatibility depends on amount of tools (rootkits, ddos projectors, threat sensors such as dragonfly, etc.). it's called firepower diversification or tool diversification.

def. strategic operatibility also depends on amount of formations at our disposal, which also is determined by amount of units at our disposal, which after reaching certain critical amount of units enable for more formations. that way we gain formation operatibility which is part of strategic operatibility.

def. diversified front is front (battlefield) consisting of many fronts. battlefield consists of many factors... for example: electronic-strategic front is such diversified front consiting of strategic battle and electronic battles mixed together.

def. weapon of scale (heavy weapon) is expensive large weapon such as large computer consisting of many expensive parts. it is often 'escorted' by mixing it with lighter versions of such. there can be heavier and lighter weapons, it's relative. where's the border between units then? wherever we put such. different units can be also under different commands.

example: heavy-diversified front can consist of heavy weapons mixed strategically (in proper formation, perhaps more) with light weapons. preferred weapon for this front would be a battery of computers (cluster), which can be armed against light threats, heavy threats or mixed threats.

example: heavy computing unit (cluster) is treated as single unit. it might consists of many units on a different scale. firepower is still of 1 unit, but it is different front (heavy front), which gives operational (operatibility) advantage. we can say that on this front one such unit can defeat 108 units of given type, because of it's operatibility. we can call it fireforce.


Stitie Space and Distributed Machines.

Stitie Space is Distributed Machine (Cluster).

Every point in such a space has potential for machine, such as Stitie Space, to be there - it is recurrential.

It does not have to be filled in full, any point in such space, or space as a whole.

See also: Stitie Machine 1.1 'Sunsail' for Stitie Space.

Jidams, Forms of Energy and Light.

i think that computers can coordinate forms.

i think that quantum physics is about energy and more.

combining such can make for forms of energy and light, Jidams.

i think that they can be presented with 3d holo projectors that are future or modern solutions.

but not without math - geometry and 3d matrix computations. i have stitie machine for that.


starting to add Quantum Physics and Energy Physics to Dragonfly Algorithm from now on... learning time will take about 10 years then we'll see.

'pure' computing times are over long time ago anyway.


Interface Points and the Internet.

Stitie Spaces or their parts can be connected with each other via so called 'Interface Points'.

If done via the Internet, TCP or UDP protocols are used, properly as neccessary. But there can be in-single-space, in-memory or other, for example LAN implementations.

In the Internet.

Interface Point takes a Sunsail to be connected with other Stitie Space's Sunsail, and destination's IP address and port as parameters. It can be one-directional or two-directional.

Before accepting a LightPoint, State or Strategy change, an 'Interface Point' can check security certificates' set and process transmitted data and/or code, transforming them if neccessary.

Interface Point accepts data and changes Stitie Space it's connected to when receiving data, by modifying proper Sunsail. It can also send data to other Stitie Space's Interface Point which acts similar way.

Interface point reacts to Sunsail's events, such as afterStateChange(), to send data to other Stitie Space's Interface Point and Sunsail. Or can be contacted directly to send data and/or code. It uses queue buffer to not block Sunsail it's connected to, and can inform about overflows when queried, if possible.

There should be option to send request to execute transmitted code, perhaps together with data in destination Stitie Space.

There should be 'Teleporting Router' implementation which allows for routing 'Command Chain' via multiple 'Stitie Spaces' and internet nodes that are part of such, along unambiguously and precisely defined path.

What is cluster?

Cluster is two or more computers communicating, doing tasks together.

Cluster can run distributed applications - applications that run on two or more computers, sharing resources, goals, solving problems.

Computational Pyramid.

Any expression can be represented in form of a tree.

In Three Dimensions, it can look as pyramid if neccessary, with lower levels of such a pyramid providing partial results to upper levels of computing machines (Master-Slaves or Master-Workers Model).

It's better than it seems when we use Stitie Space recurrentially.


How to arrange safer route via the Internet?

Buy hosting service(s) in strategic place(s) and install webapp proxy server(s).

For a truly safe route via the Internet, many safe nodes are needed. To succeed this has to be done not without alliance with other similar people.

See also: Communication via 3 nodes.


Hidden Communications Threat.

Another threat to the law and order is hidden communication - using nonstandard 'physical links' and 'private internet'.

It is more expensive than 'home made drone army' and use of such implies high possibility of espionage, sabotage, crime and perhaps terror.

Network Interface - Standarization Request.

i think that network interfaces should have not only unique number, but also GPS or similar technology.

i also think that network interfaces should be network cards integrated with routers.


Device Formations, combat and communication tactic.

Devices, such as computers in the Internet can communicate using formations in 3D space.

Different formations have different properties of information flow - speed and security.

If we disable (install a backdoor that can turn computer off or report) few internet nodes, we can split formations and disorganize them, making them uncoordinated. Then we can press on with attack advantage and defeat more numerous forces with ours smaller, but better coordinated system.

If we engage and tie part of enemy forces, we can defeat larger opposing force at once. For example with well-thought and well-executed DDOS attacks from fortified (well secured: with proper firewall, minimalistic, designed to last for long, internet nodes).

Reserve forces can help to disable and counter opponents that engage and tie our forces. Often best as second wave attack, after opponent reveals itself first.

After certain time of combat and analysis, more dedicated forces can engage and disable most problematic opponents, revealing themselves from reserves, like ninja from the shadows.

For example, simplest attack plan:

We have 12 computers.

* initial 3 computers open attack, in attempt to disrupt formation.
* 3 next computers tie half of the opposing forces.
* initial 3 computers press on with formation disrupting assault.
* 6 next computers, in 2 units of 3 wait for proper moments (proper moment is either stalemate or when we start to lose - when computer fails to send periodic ping signals, or when enemy reinforcements arrive) to engage most problematic opponents, either as disabling forces, or as engaging forces. we do not have to use all forces sometimes, when we are losing too bad.

Mega-LAN star-topology style stands no chance.... perhaps.

How such combat can look in practice?

Hacker overwatches attacked and attacking system, by checking reports - pings, network traffic, backdoor reports and formations (which system communicates with which), perhaps more.

See also: Shapes, Forms, 108 Number & Strategic Botnet, Form 4x3, Everyday tea for information problems, or DDOS attack (for everyone), Packet Flooding & DoS attacks.

Stitie Space as Device's 'nervous system'.

Stitie Space when externalized in form of tiny computers communicating with directional rays (lasers for example) can serve as 'nervous system' for devices.

it's dangerous when misused, but isn't metal also? after all carbines are made from such.


Simple compiler design.

Compilers consit of front (analysis part) and back (code generation part).

Code in a source language is analyzed, intermediary data structure generated, such as Abstract Syntax Tree, then from it code in target language generated.

Purpose for this is that we can use many front and many back parts, translating from many source languages (such as C, Pascal, Java) to many target languages (for example machine codes for different processors, or other programming language such as C).

Parsers (analysis and intermediary structure generation parts) are created by designing and writing grammar in any form, including tree if neccessary, then using automated tool such as JAVACC or writing parser code manually.

Code generation part is simple in it's most basic idea - traverse tree, analyze it, look for certain patterns (not only leaves) then remove them from tree and generate code in target language, instruction by instruction.

In advanced compilers there are many other methods for improving such process, such as including code optimization part before generating code (for example by transforming intermediary data structure).

Source: [16], my own programming experience (i wrote parser professionally before).

See also: Context-Free Grammars.


Context-Free Grammars.

Context-Free Grammars can be used to check if character string belongs to context-free language. For example, if a written text is program in given programming language.

Such grammars generate a tree structure, such as AST - Abstract Syntax Tree, which has uses for example in writing parsers for compilers for programming languages.


Tree representing single production from grammar is called elementary tree. Any 'word' extension in grammar can be represented by elementary tree.

Tree representing this extension is created by joining elementary trees representing single productions that are part of word extension.


Grammar G is G = (VN, VT, v0, P).


* v0 is root node,
* vn is node from set of nonterminal symbols VN, or tree nodes that are not leaves.
* vt is node from set of terminal symbols VT, or tree nodes that are leaves.
* P is production set, production is one step of terminal symbol extension from root node v0. Production extends nonterminal symbol into an list(s) of terminal and nonterminal symbols.

Word generated by such context-free grammar is list of terminal symbols or leaf nodes that together make for example, for instruction in programming language.

for example:

if ( a == 2 ) a = 3;

is word, where terminal symbols are : if, (, ), a, ==, 2, =, 3, ;.

Extension is list of steps taken to acquire terminal symbol, starting from root node. Or a path in a tree. It consists of sequence of productions.

Example few productions that can be used as part of a single extension from a Grammar can be:

instruction -> conditional_instruction | assignment_instruction | iteration_instruction

conditional_instruction -> if ( logical_expression ) instruction ;

logical_expression -> logical_expression && logical_expression | logical_expression || logical_expression | true | false

these productions are too incomplete to form a fully working programming language.

Source: [7], BNF notation on Wikipedia.

Communication via 3 nodes.

By node in this post we understand internet device, network of such form a graph.

Communication from node A to node B can go through other transitory node T.

Then we can reach node B with message with 100% success rate if node T won't fail, at time tT = 1 unit.

If we have three transitory nodes T1, T2 and T3 then we can send messages via them in many ways.

1. Via random or predetermined node.

If that node fails, signal needs to be retransmitted.

2. Via all nodes at once, whole message.

It succeeds as long as at least one transitory node does not fail, but signal can be captured easier.

3. Via all nodes, 1/3 of message through each.

Transmission fails if at least 1 node fails. But rest of message can be resent later. There's less risk of capturing whole signal by opposing forces. If it's encrypted, it's hard to decipher that way. It's faster transmission as well.

4. Via all nodes, 2/3 of message through each. (different 2/3 via each).

Transmission succeeds 100% of time when at least two nodes won't fail. Whole signal is captured if 2 transitory nodes are captured. When one node won't fail, 2/3 of signal are sent, then rest can be transmitted again.


(trying to define, definitions can change later).

def. Communication occured when message was sent and arrived at it's destination.

def. Full Communication occured when all messages were sent and arrived at their destinations.

def. Secure Communication occured when message was sent and arrived at destination securely.

def. Full Communication at discrete moments occurs when at discrete moments all messages were sent and arrived at their destination.

example: with this system and amount of data, as far as we know, with pessimistic time measurement, secure full communication occurs every 20 seconds. on average it occurs every 5 seconds.


Stitie Space - Node Graph Persistent Connections.

If we have coordinates of two nodes in 3d space, such as Stitie Space, we can find communication path(s) between such nodes easily using simple mathematics. (other paths can still exist).

We can define classes for such communication paths, and can index and manage them at Stitie Space.

If we have names associated with coordinates, we can find coordinates even if Stitie Machine at coordinates moves, for example: by calling carefully 'get' and 'set' accessors.

When we 'transfer' a Stitie Machine from one coordinate to another, we can find it's coordinates by Stitie Machine's name. This allows communication paths to adjust and reform dynamically after one or even both of it's end points move. This is what we'll call 'persistent connection' in context of this blog.


Numen functionality.

Stitie Space can be object inside single computer's memory, or a way to organize many internet devices or computers into a collaborating network.

In former case, Stitie Space transformation is called: MATEN, in latter: NUMEN.

In latter case, change of state and/or strategy is also general idea of updating software and data on such device.


Intermediary Forms.

MATEN Forms can be hierarchized, organized in a Graph data structure.

This means that instead of reaching a 'zero state' before invoking new Form, we can invoke an 'Intermediary Form' that is 'closer' to the 'empty form' (or zero state), but not quite it. Then proceed with invoking Form available from that 'Intermediary Form'.

There can be any number of more or less 'Extended' Forms, and 'Intermediary' Forms in between. Each of such can be goal of reducing or extending step. Extended MATEN can go through any number of steps during reduction and through any number of steps during extension phases.

There can be restrictions on Graph's shape and rules of traversal between nodes on such Graph. For example: 'up' or 'down' only, with 'shared nodes' between paths.

See also: More about 'Ola AH' Language (background).

Stitie Machine 'Core Go' Implementation.

There will be no Stitie Machine implementation in Google Go programming language, if there are no proper Object Oriented programming mechanisms supported in that language.

For now at least, this Language is well suited for different tasks.

update: added a screenshot, with a proper date included: '5/18/2015'.


Finite State Automatons and Regular Expression Basics.

There's connection between finite state automatons and regular expressions.

Finite State Automatons accept input, if it matches a Pattern defined by a Regular Expression. Otherwise they process input and do not enter 'accepting' state.

That's how we can find patterns in an input - by creating Finite State Automaton to work through input, and check if it enters accepting state.

 photo fsa_zpse9ad8e28.jpg

Finite State Automaton, often named Finite State Machine (FSM).

Source: [7].

See also, if You wish: Joining Finite State Automatons.