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


Strategic Forces Reassignment.

This is a basic strategic maneuver, but still can be very effective.

To not neccessarily increase numbers of forces, but to reassign them to properly selected opponents.

Every strategic apparatus should include such.

In context of the Internet Warfare, Stitie Machine & Stitie Space allow for this.


Core, N-Forces.

in context of this blog:

Often Forces Composition (for example for an attack) consists of many forces.

There's Core of Forces which performs given task.

There can be an escort which provides support (for example, light DDOS Projectors which tie Opposing Forces) while Force Core performs it's task (for example rootkit installer that performs a take-over operation on Opponents' Computer).

There can be Force Core that consits of N-Forces which together perform tasks. For example two rootkit installers which must attack N machines to take over such simultaneously. With DDOS projectors support, it can be called N-Forces Core with escort.

For example: we can have Force Core of 2 Forces with an escort, composed of 2 Rootkit Installers with escort of 4 DDOS projectors. Here 1 Rootkit Installer with two DDOS Projectors would form a Single Force with an escort.


Bitonic Sorting in Cryptography.

i think that Bitonic Sorting can be used as a trapdoor function, more or less.

When properly done, amateur programmers without costly parallel machines won't be able to efficiently sort data... and such sorting can be part of a decryption algorithm.

This would eliminate most of 'amateurs' as possible decryptors to be checked for breaking a cipher. Only people with knowledge & resources - usually companies - would be able to break that kind of cipher.

i think that sensitive data encrypted that way is no match for real Intelligence Agencies, but would save many people a worry of a data being leaked during transmission to most of other individuals, most of companies & most of institutions.

Bitonic Sequence.

A sorted sequence is a non-decreasing (or non-increasing) sequence.

A bitonic sequence is a sequence with x0 ≤ ... ≤ xk ≥ ... ≥ xn-1 , or x0 ≥ ... ≥ xk ≤ ... ≤ xn-1 for some k, 0 ≤ k < n.


Objects, Classes, Modelling.


Classes can be compared to technical designs of machines, objects to machines... from one technical design, many machines can be created.

This is simplification, for objects can also represent beings, qualities, or even different ideas from ones mentioned just before.

That is, objects can be symbols (symbols represent ideas) in a play of ideas, with a computer program being a plan for such a play, a process - a running program: this play in action with side effects, and computer system: a container for such a play.

Technical details.

Class is abstract data type with full or partial implementation. Classes form a static structure of a program.

Object is instance of a class during a runtime. Objects form runtime structures.

Objects together can collaborate, communicate, and model a system.

Source: [27], perhaps more.

See also, if You wish: Type, State, Context, Object & Class.

Array Data Type.

In Computer Sciences, an array type is a data type used for keeping a collection of elements of a certain data type together.

Programming languages often support this data type as part of their syntax.

There can be, for example, an array of integer numbers declared & defined as follows:

  int num[SIZE];


- int is type of elements inside array,
- num is array's name,
- SIZE is a constant, that is used in determining array's size.

Access to each of variables that is part of an array is done via the index variable or a constant, for example as follows:

  num[3]; // this is expression that gives value of a num array's variable at position 3.
  num[i]; // this is expression that gives value of a num array's variable at position
             // determined by value of 'i' variable.

  num[3] = a; // this is assignment instruction that assigns value of a variable 'a' to a num              // array at position 3.

There can be multidimensional arrays, or arrays of arrays, for example:

  int num2[SIZ_DIM_1][SIZ_DIM_2]; // 2-dimensional array declaration & definition,
             // without initialization perhaps.

  a = num2[0][0]; // expression evaluation & assignment to 'a' variable.
  num2[1][2] = a; // assignment to array variable at position (1,2).

  int num3[SIZ_DIM_1][SIZ_DIM_2][SIZ_DIM_3]; // 3-dimensional array declaration
             // & definition, without initialization perhaps.


Access time to any of array's variables can be measured by a constant, or should be such, regardless of array's size.

See also: Basic Data Structures.


Basic Data Structures.

Data can be stored in a primitive variable or in a data structure, more or less complex.

Each of data structures has operations associated with it.

For example, a stack has two operations: push, pop.

- push: puts something (data in some form) on top of a stack.
- pop: retrieves something (data in some form) from top of a stack, removing in process.

Basic data structures include:

* Array,
* List,
* Set,
* Graph,
* Tree,
* Map,
* Queue,
* Stack.

There are varying implementations to each of above data structures, each with different qualities & costs.

Proper choice of data structure & algorithm is often a first step in finding a nice solution to a problem that can be solved by a computer program.

For details, see: [4], [19], perhaps more.

See also: Sorting.

Neural Network Learning.

in context of Artificial Neural Networks:

For a 'neuron' to learn something, there must be:

1. Change.
2. Measure.

Then we can analyse how this change affected 'neuron', and how closer or further away it is from it's goal, a desired behaviour.

With enough of time, with analysis, with a certain degree of control of changes, changes might become more rapid, bigger, smarter, better.

See also: Neural Networks, Stitie Space, Simple Artificial Intelligence.

Optimization Triad.

i think that software optimization should happen on multiple levels.

Mostly i'd focus on three:

1. algorithmic optimization, so that programs scale well with amount of data to be processed,
2. bottleneck optimization, so that slowest (or for example, most memory consuming) parts of the program are given extra care,
3. low-level optimization, so that we utilize modern hardware to the fullest,

Problem is usually, a lack of resources such as time, programmers, money.

see also, if You wish or need: Software Costs & Optimization, Optimization Costs, Assembler Optimization, Cache.


Simple Artificial Intelligence.

In my opinion, a simple AI (Artificial Intelligence) can be modelled by a Finite State Automaton (or a Finite State Machine, FSM), that includes nondeterminism.

Part of input used for choosing a transition between states can be random data.

That way, for example, a Computer Game AI players can be more challenging opponents.... human players won't be so sure about AI players' decision making.


then we can, for example, each of such finite state automatons, run as a separate process / thread.

each of them being a 'neuron' responsible for something.

they can communicate & cooperate.

we can give / balance priorities & resources to such.

for example, we can have processes responsible for security that can be given a higher priority & more resources at times of danger.

programs can detect higher priority / more resources and react, for example by activating more functionalities, passing these resources to other processes. i call this a 'tiered functionality' that is activated by a priority level and available resources.

See also: Neural Networks, Stitie Space, Neural Network Learning.

Neural Networks, Stitie Space.

Neural Networks in Computer Science.

In computer science and related fields, artificial neural networks (ANNs) are computational models inspired by an animal's central nervous systems (in particular the brain) which is capable of machine learning as well as pattern recognition. Artificial neural networks are generally presented as systems of interconnected "neurons" which can compute values from inputs.

An artificial neural network is an interconnected group of nodes, akin to the vast network of neurons in a brain. Here, each circular node represents an artificial neuron and an arrow represents a connection from the output of one neuron to the input of another.

Stitie Space.

Stitie Space is a Space in which such a neural network can be modelled, and can run (do it's work).

Source: Wikipedia.

See also: Stitie Machine 1.1 'Sunsail', Simple Artificial Intelligence, Neural Network Learning, 'Supervised Learning', Stitie Space, Genetic Algorithms.


Factorization Tree.

108 number, as well as any other number, except for zero, in most sane situations, can be factored into divisor(s).

From divisors, a tree can be constructed.

Java source code (with unpolished output, other than that, seems fine):

package ft;

import java.util.LinkedList;
import java.util.List;

public class NumberFactored {
  private final int val;
  private final List<NumberFactored> divisors = new LinkedList<NumberFactored>();

  public NumberFactored(final int v) {
    this.val = v;

  private void evaluateAndSetDivisors() {
    if (val < 2) { return; }
    int threshold = (int) Math.floor(Math.sqrt(val));
    for (int i=2; i <= threshold; i++) {
      if ((val % i) == 0) {
        final NumberFactored divisor = new NumberFactored(i);

  public String toString() {
    final StringBuilder result = new StringBuilder();
    for (final NumberFactored divisor : divisors) {
      final NumberFactored nf = new NumberFactored(val/divisor.val);
    return result.toString();

  public static void main(String[] args) {
    final NumberFactored n = new NumberFactored(108);


Sample output:




MATEN Sorting.

- is it possible to Sort data using MATEN functionality?
- i think yes, should be fine, if not 'superstitions'.

- how data in Stitie Space can be sorted?
- in many ways, for example: we can determine points order, and define a 'lesser or equal' relation between LightPoints.

- can every problem be solved using MATEN functionality?
- no.


Data can be sorted.

Sorting is a problem quite often solved by computers & programmers.

Sorted data sets are much more useful usually, than unsorted data sets.

Sorted data sets are easier to search for information, among other qualities they possess.

There can be various criteria by which we can sort data.

There are various sorting algorithms, with different algorithmic speeds and other costs, for different data structures, and for different data.


Why certain sorting algorithms are better for certain data? Because the more we know about data processed, the more we can take advantage of that information.

For example: if we know that part of the data is already sorted, and if we know which part is unsorted, then we can sort just unsorted part of it, instead of going through the whole data set.

For example: if we know that data has such a structure that after '2' numbers there are '3' numbers, we can incorporate this into sorting algorithm, properly.

if it's a set of integer numbers, this can be used like that:

- we categorize numbers into smaller than '2', '2', '3', larger than '3',
- then we can proceed, taking ('2','3') pairs from data to be sorted, sorting them properly,
- then we can sort remaining sets (smaller than '2', larger than '3'),
- then we can merge partial results of sorting operation into a 'whole sorted data set'.

with proper data structures (ones that let us add & remove data from 'data sets' efficiently), this is a quite fast sorting algorithm for our data, but it's worse for data with other, different qualities.


For details, see: [4], [19], perhaps more.

See also: Basic Data Structures.


Supporting Fire in a context of Hacking.

i think but am no expert...

supporting fire is about attacking to engage or destroy enemy, relieving our forces in maneuvers.

in context of hacking this would be most likely DOS/DDOS attacks at network nodes (computers etc), which pose possible/real threats; or 'turning off' computer systems more permanently, for example with scripts that install hacks then automatically turn off computers, or perhaps there are even hardware destroying hacks (i don't know), or other attack methods with such effects.

i do not know if it's true that it's heavy losses on both sides, but i imagine losses happen during such maneuvers.

see also: Device Formations, combat and communication strategy.

Wireless, Mobility.

Wireless - nature of the communication networks.
Mobility - quality of network, enabled for example by it's wireless nature.

Source: [3].

one can think that dynamic data/code (state/strategy) transmission between network nodes is also part of mobility within the Internet.

State/Strategy transmission is part of Stitie Space functionality (part of Stitie Machine 1.1 'Sunsail'), as well as part of Stitie Machine 1.1 'Sunsail' functionality, as well as part of Stitie Machine 1.0 'Core' functionality.

see also: How to arrange safer route via the Internet?, Stitie Machine 1.1 'Sunsail', Stitie Machine 1.0 'Core'.

'Doctrine: Airpower'.

'Air Power rests at the apex of the first triad of victory, for it combines Mobility, Flexibility, and Initiative.'

-- quote from 'Sid Meier's Alpha Centauri / Alien Crossfire', a Computer Game.

one can think that this doctrine can apply to the Internet warfare as well.

then we can strike where we want & when we want, to protect.

it's important part of Dragonfly Algorithm.

* Speed - not yet, but planned optimizations;
* Flexibility - mostly because of Turing Machine;
* Initiative - i do not know of such projects yet, i've considered initiative as part of project... including counterinitiative.

see also: Stitie Turing Machine, Initiative and Counterinitiative.


Use Cases & Attributes.

i don't know precisely what an attribute is, but it's a tool, perhaps more, perhaps less.

i think that programming language instructions are attributes too, perhaps.

use cases describe how tools can be used to achieve certain goals.

from my view point at least.