Object Oriented Analysis, Design & Modelling.


Object-oriented analysis and design (OOAD) is a popular technical approach for analyzing, designing an application, system, or business by applying the object-oriented paradigm and visual modeling throughout the development life cycles to foster better stakeholder communication and product quality.

Object Oriented Analysis.

The purpose of any analysis activity in the software life-cycle is to create a model of the system's functional requirements that is independent of implementation constraints.

In the system analysis or object-oriented analysis phase of software development, the system requirements are determined, the classes are identified and the relationships among classes are identified, appropriate models are created.

The primary tasks in object-oriented analysis (OOA) are:
- Find the objects,
- Organize the objects,
- Describe how the objects interact,
- Define the behavior of the objects,
- Define the internals of the objects.

This serves as a way to understand the 'domain knowledge' - knowledge needed to write software that is not neccesarily the Computer Sciences-related.

Common models used in OOA are use cases and object models. Use cases describe scenarios for standard domain functions that the system must accomplish. Object models describe the names, class relations (e.g. Circle is a subclass of Shape), operations, and properties of the main objects.

Object Oriented Design.

Object-oriented design is the process of planning a system of interacting objects for the purpose of solving a software problem.

The input for object-oriented design is provided by the output of object-oriented analysis.

During object-oriented design (OOD), a developer applies implementation constraints to the conceptual model produced in object-oriented analysis. Such constraints could include the hardware and software platforms, the performance requirements, persistent storage and transaction, usability of the system, and limitations imposed by budgets and time. Concepts in the analysis model which is technology independent, are mapped onto implementing classes and interfaces resulting in a model of the solution domain, i.e., a detailed description of how the system is to be built on concrete technologies.

Designing concepts:
- Defining objects, creating class diagram from conceptual diagram,
- Identifying attributes,
- Use design patterns (if applicable),
- Define application framework (if applicable): Application framework is a term usually used to refer to a set of libraries or classes that are used to implement the standard structure of an application for a specific operating system. By bundling a large amount of reusable code into a framework, much time is saved for the developer, since he/she is saved the task of rewriting large amounts of standard code for each new application that is developed,
- Identify persistent objects/data (if applicable): Identify objects that have to last longer than a single runtime of the application. If a relational database is used, design the object relation mapping,
- Identify and define remote objects (if applicable).

Output of object-oriented design:
- Class diagram: A class diagram is a type of static structure UML diagram that describes the structure of a system by showing the system's classes, their attributes, and the relationships between the classes. The messages and classes identified through the development of the sequence diagrams can serve as input to the automatic generation of the global class diagram of the system.

The Acyclic dependencies principle.

The dependency graph of components should have no cycles. This can be realized by abstracting common parts of the inter-dependent objects & moving into other abstract object(s), as well as by using the Dependency Injection Design Pattern. There are tools such as the Spring Framework that organize structure of the project & allow to easily use the Dependency Injection pattern as well. A part of 'Ola AH' Programming Language's semantics - Stitie Space - will also allow to model the object graph of a program & skillfully use the Dependency Injection Design Pattern as well.

Circular dependencies can cause many unwanted effects in software programs:
- Most problematic from a software design point of view is the tight coupling of the mutually dependent modules which reduces or makes impossible the separate re-use of a single module,
- Circular dependencies can cause a domino effect when a small local change in one module spreads into other modules and has unwanted global effects (program errors, compile errors),
- Circular dependencies make software to be hard to test,
- Circular dependencies can also result in infinite recursions or other unexpected failures. Circular dependencies may also cause memory leaks by preventing certain very primitive automatic garbage collectors from deallocating unused objects.

Object Oriented Modelling.

Object Oriented Modeling (OOM) is a common approach to modeling applications, systems, and business domains by using the object-oriented paradigm throughout the entire development life cycles. OOM is a main technique heavily used by both OOA and OOD activities in modern software engineering.

The benefits of OOM are:
- Efficient and effective communication within & between Team(s),
- Models are tools that allow to quickly, visually analyze the Project & the Problem Domain, to Simplify & Abstract the Design.

The Unified Modeling Language (UML) is a visual, popular international standard language used for object-oriented modeling, there are other solutions as well.

- Wikipedia,
- My own knowledge & experience.

See also, if You wish:
- Object Relationships Modelling & Analysis,
- UML,
- Iterative Development vs. Waterfall model.


The Less Code, The Better.


It is a good programming practice to solve problems using as little of code as possible.

With less code lines, program is more readable - there are less errors, code changes & debugging are faster.

There is research that proves that with less code lines there are less errors.

Number of code lines is one of metrics, by which code's quality can be measured.

One should not add extra code for future features in advance.

With time customer requirements might change, and this extra code only obscures project's clarity.


Memory, Cache, Processor Use & 'Ola AH' Programming Language.


Modern computers' processors are about 1500 times faster than memory.

Hard Disk Drives or other external memory devices are even slower.

Many programs often wait for a memory access after every a few of processor instructions.

It's quite inefficient, but simple to code.


There are registers & tiered cache inside the processors.

When a program's part can be loaded into a cache or use only registers it does not have to wait for memory access and is much faster; it's harder & more expensive programmer-time-wise to write such programs however. Programmers are paid per hour of work and this is not a small amount of money as well.

There are other optimizations too, for example - caching partial computations so these do not need to be computed again or read from external media device.

For even more of optimizations, please refer to books about 'Algorithms & Data Structures' - for example: [2], [4], [19], [33] (see right border of this blog for literature section).


Simple programs as many of web-pages do not need to be blazing-fast, they should be cheap instead to make & change.

In these cases programmers should & do optimize their own time at cost of program's efficiency.

It's cheaper to change hardware infrastructure or to buy many computers than to pay many of very skilled programmers for long times of optimizations.

Often a time of make is crucial too, for example when business wants to release a product before competition.

'Ola AH' Programming Language.

i think that with 'Ola AH' Programming Language it should be possible to take advantage of tiered-memory-pyramid-of-needs, as well as of multi-threading of standard processors, as well as of the RISC machine architectures to accelerate the computations.

RISC stands for 'Reduced Instruction Set Computing' machines, including ARM - 'Advanced RISC Machines'. These use very many of simple & cheap processors working in parallel.

Exact details to be designed still, it will be important when the compiler will be implemented.


'Ola AH' Programming Language for 3D Modelling & Animations.


One of use cases for 'Ola AH' Programming Language is 3D Rendering, Graphics & Animations.

Stitie Space - Based 3D Modelling & Animations.

Stitie Space can be seen as a container for objects, container with coordinates.

Visual object's information can be stored within one of Stitie Machines within Stitie Space, in an 'Anchor Point'.

Within Anchor Point object, shapes, colours & animations data can be stored, then Mindfully Visualized.

These objects can move & animate, change colours etc.

Anchor Points can move as well.

One of possible effects can be transforming Space into another Space.


Ideas & Feedback for 'Ola AH' Programming Language are Welcome.

First stage - design stage - for 'Ola AH' Programming Language is nearing end, it's scheduled until April 2017.

By 1 April 2017 i should start writing 'Ola AH' Programming Language interpreter in Java.

i think i'll start with modelling software constructs, instructions & data types, as well as documenting these properly on this blog.

It'll be possible to program with these code pieces using a 'program interpretation tree' at first, parser will come later.

By 1 Jan 2022 - beta version or an RC version (feature complete, but perhaps untested) of 'Ola AH' Programming Language should be complete, with parser, intermediate data structure, interpreter & other parts.

C/Asm compiler for 'Ola AH' Programming Language should come later.

Meanwhile, ideas & feedback for what's planned is welcome - feel free to contact me:
- via e-mail: neomahakala108@gmail.com,
- in comments to this article,
- other ways if You prefer.


Space, Transformations & Recursion.


... had insights that this has uses in Mathematics as well as in Physics, probably more.

... i was exploring Linear Algebra, Geometry & other fields of Mathematics - i plan to study Mathematics at Warsaw University in future as well, i plan to learn Physics from books after that, and other Sciences (Electronics, Chemistry, Biology, Nanotechnology, Nanoelectromechanical Systems - NEMS) as well.

Stitie Space is a 3D objects matrix with convenience methods to animate & transform objects within.

Stitie Space can be Recursive, as objects within can be treated as machines that can run Space(s) within; that way Space can be more dense at certain point(s) or continuously - as much as available resources allow; This can include GRIDs, as machine with Stitie Space objects can be Distributed & Recursive so it scales well with hardware/software infrastructure investments.

Non-Cartesian Spaces & Transformations.

By Space i understand a mathematical construct spanned by a linearly independent, minimal vectors set (a basis for a 'vector space').

i think that Space with Cartesian coordinates has two perpendicular axes, with consistently same unit of distance between values on each axis. i think we can abstract from this however, and talk about 'n-dimensional Cartesian Spaces' with an amount of n perpendicular axes.

Non-Cartesian Spaces do not neccessarily have perpendicular axes, might have different number of axes that two, it is not neccessary to have distance between points on each axis the same - can be more dense or sparse around certain point(s). It is also possible for points in Non-Cartesian Space to be in Relation(s), for example:

  R = { 1 < 2, 2 > 3, 3 < 4, 4 < 2, ... };

Since we are using computers with a finite memory amount, we use discrete numbers for points & values on axes.

We also should use unambiguous 'position values' for points, not only an 'order relation' specified for these, as well.

One of future features planned for Stitie Space is space transformation(s) & projection(s) on different Cartesian or Non-Cartesian Spaces; this is about transformation, not only visualization in different Space(s).

Distance measuring between points in this/these Space(s) can be defined many ways as well (for example by number of 'hops' in the object graph, or by actual distance between objects when projected on the 'n-dimensional Cartesian Space').

Handling Many Objects at the same Coordinates.

With Recursion of Stitie Space, this can be done easily - a machine with object at coordinates creates Space(s) within, then 'sets up' multiple objects there at proper Coordinates, then concurrently manages interactions both within a Space, between objects in different Spaces within, and between object(s) within with the objects in the 'outer' Space(s).

Therefore Space Transformations can occur from any Space to any other Space, even if this potentially can cause 'collisions' of having multiple objects at the same Coordinates in the 'Result Space'.

Use example.

We can model gravity field around a 'magnet', where increases in 'attraction force' are higher near the magnet, and lose it's magnitude away from the magnet.

We might want to model Space with more dense coordinates near the magnet(s), and more sparse outside - to save the resources.

We might want to use transformation(s) as 'magnet(s)' move(s), using MATEN or/and Prism - Stitie Space's functionalities for transforming Space, or using other available ways as well - implemented already or planned in future.

See also, if You wish or need, ... : Stitie Machine 1.1 'Sunsail', Stitie Machine 1.2 'Satellite', Stitie Machine 1.3 'November Rain', Agile Transformation of Information State.

Esoteric Programming Languages, Funges & Ola AH Programming Language.


An esoteric programming language (sometimes shortened to esolang) is a programming language designed to test the boundaries of computer programming language design, as a proof of concept, as software art, as a hacking interface to another language (particularly functional programming or procedural programming languages), or as a joke.

The use of esoteric distinguishes these languages from programming languages that working developers use to write software.

Usually, an esolang's creators do not intend the language to be used for mainstream programming, although some esoteric features, such as visuospatial syntax, have inspired practical applications in the arts.

Such languages are often popular among hackers and hobbyists.

Usability is rarely a goal for esoteric programming language designers—often it is quite the opposite.

Their usual aim is to remove or replace conventional language features while still maintaining a language that is Turing-complete, or even one for which the computational class is unknown.


A funge is an esoteric programming language which models its programs as metric spaces with coordinate systems (often, but not necessarily, Cartesian) and which execute instructions located at points in their program space by moving an instruction pointer (a position vector which indicates the currently executing instruction) through that space.

Different instructions determine the direction in which the instruction pointer moves, and consequently, the sequence of instructions that is executed.

The current official standard for the behaviour of these programming languages is the Funge-98 specification. This specification is a generalisation of the semantics of the Befunge programming language, which has a two-dimensional toroidal topology.

Languages which adhere closely to this standard, such as Unefunge (one-dimensional) and Trefunge (three-dimensional), are sometimes called funges, while more 'distant relatives' which differ in significant respects, such as Wierd, are referred to as fungeoids.

'Ola AH' Programming Language.

'Ola AH' Programming Language has capability of either following classical programming methodologies, or, with use of Stitie Space, organize instructions to be executed as well as state (data) in the three dimensional space.

It is both practical and esoteric language according to design, with classical & visuospatial state/instruction organization.

i am using esoteric ideas in this a programming language i am creating in two ways:
- by experimenting with code & challenging programming languages' limits,
- by using Buddhist, Hermetic Qabbalah's & Wiccan/Witchcraft's symbolics, that are related with Many Aspects of Spiritual Ways.

i am trying to enter spiritual & esoteric markets as well, adressing the needs of the people for whom spiritual & esoteric ideas are important.

See also, if You wish or need, ... : Esoteric programming language, 'Ola AH' as a 4GL Programming Language.


Ockham's Razor of the Scientific Focus.


Occam's razor, also written as Ockham's razor, or law of parsimony, is a problem-solving principle attributed to William of Ockham (c. 1287–1347), who was an English Franciscan friar, scholastic philosopher and theologian.

The principle can be interpreted as: 'stating among competing hypotheses, the one with the fewest assumptions should be selected'.

According to Ockham, 'simpler theories are preferable to more complex ones'.

Discriminating Wisdom.

Discriminating Wisdom in Buddhism is the wisdom that allows to see things (for example: scientific assumptions) clearly, 'as they are', in a separation as well as a part of larger whole, nondually.

Uses in Science.

Assumptions can be complex or simple. Complex assumptions consist of multiple assumptions, either complex or simple, or of a mix of these.

Complex assumptions can be reduced to a set of simpler partial assumptions, then can be looked with a discriminating wisdom, modelled and analyzed to see if any of the partial assumptions can be removed for a simpler model.

Simpler models often do not restrict us so much, allow for more options based on a fewer of the assumptions.

An Example.

To have a square precisely defined, we need to provide either:

1. A vector/turn definition.
- a vector with a direction,
- a turn at the vector's end.

2. A two straight lines with a point definition.
- a straight line,
- a second straight line, parallel but not overlapping first line,
- a point.

This can be reduced using the 'Ockham's razor' and the 'Discriminating Wisdom' to a basic sets of simple partial assumptions:

[Discriminating wisdom is used to reduce complex assumptions into a set of simpler partial assumptions, then to analyze].

[Ockham's razor is used to remove redundant information, such as the requirement for a point between two lines to be placed exactly in the middle of a square - a perpendicular straight line can be placed through this point, then this point can be moved along the perpendicural straight line into the midst of the square].

Let's not prune too much or too little of the neccessary premises information, however. We need all of required premises to do attribution in a sane way - to jump into a conclusion in a sane way.

1. A vector/turn definition.
- we know a starting coordinates of a vector,
- we know the end coordinates of a vector,
- the starting and end points of a vector are not overlapping,
- we know a turn at the end of a vector: either to left or to right.

2. A two straight lines with a point definition.
- we know an equation of the first straight line,
- we know an equation of the second straight line,
- lines defined by equations are parallel,
- lines defined by equations are not overlapping,
- we know coordinates of a point.

By looking at both definitions, we can see that definition with a vector/turn requires fewer assumptions about our knowledge of a square than a definition with two lines and a point.

Our first definition is simpler and therefore superior by principles of the Ockham's razor theory.

See also, if You wish or need, ... : Buddhism, Arts & Sciences.


'Ola AH': a Concurrent or the Real-Time Language?


Recently had lot of insights concerning 'Realtimeness' of 'Ola AH' Programming Language i am to create - or more precisely, lack of a 'Real Time Language Features' in this language by it's design.

Current State.

'Ola AH' Programming Language was designed without strict real time features in mind, but still concurrency is important part of it. It would take a lot of effort to change this now, and would make 'Ola AH' Programming Language much more difficult tool to learn & use.

'Concurrency' is about running software parts simultaneously & coordinating them, without bothering about 'pessimistic cases of time deadlines' for processes runs. Concurrent systems still can work in real time.

'Real Time Systems' have additional property - when a task execution time exceeds it's time deadline, we can say that system failed. It's concurrency taken to extreme.

Architecture & Operating Systems Dependency.

Exact time of an instruction running depends both on hardware architecture (parts used) as well as on the operating system & it's version.

Currently, only RT Linux supports real-time demands for personal computers, as far as i know.

Other considerations & design.

So far i don't plan to make 'Ola AH' Programming Language to acquire 'Real Time Properties', because of:
- lack of education & experience in Real Time Systems by language's creator,
- 'vendor lock' & dependency on RT Linux,
- amount of effort with regards of change required for programming language semantics (Stitie Space, Stitie Machine, State, Strategy, Router, Events, MATEN, Prism, Mindful Imaging - perhaps more),
- amount of effort required by developers using this language - both to learn as well as to use - they would need to count how much every instruction 'costs' processor-cycles-wise, other-devices-wise, taking in account operating system used, it's version, as well as hardware architecture. Amount of processors & concurrent running adds to the task's difficulty,
- with current design of 'Ola AH' it's still possible to write 'Real Time Solutions', with slight syntactical support ('asm insert' instruction & 'AH' Anti-hack mode), it's just very hard to do still,
- this would reduce this Programming Language's niche severely - language would lose it's general purpose & simplicity, as more competent programmers are harder to find and more costly to hire. personnel rotations would cost even more than that - it would take a lot of time & cost to take over a project from a former team member.


Peer-2-Peer Network with a Distributed Sitite Space.

-=- A Spherical Double-Spiral. -=-

Can be used in forming Distributed Objects in 3D,
including Distributed Stitie Space in 3D, or Distributed Hash Table in 3D,

... it has a communication cycle & fairly efficiently uses 3D Space,
... without forcing client object to reach inside, past the outer layer.
a client object can, for example scan,
(using directional/cone multicast wireless communication for example)
for 108 closest data structure objects, with load report,
then can choose either at random or by workload an object to communicate with.

... see also, if You wish: Stitie Grid.

A POV-Ray source code available for: download.
Credits: Andrea Lohmüller + Friedrich A. Lohmüller.


One can look at Stitie Space as on a data structure that manages objects storing & communication in 3D-addressed space.

Most of ideas in this article requires a version 1.2 of Stitie Space, or later, however.

In-space objects communication.

Objects within can communicate with each other without accessing Stitie Space if they have coordinates & can find path - with or without using the 'long-range links'.

This fits well with peer-2-peer communication model.

Distributed Stitie Space.

When target object's coordinates are not available, Stitie Space can be contacted for these. Client object can request for other information & services as well, but these are more expensive than independent communication & performance.

Many requests to Stitie Space in short time-frame can cause a system overload, delays in communication or crashes. But Stitie Space can be replicated & distributed in similar way as the Distributed Hash Table.

In this case response or a service might not be immediate, because of data synchronization with other Stitie Space instances, and because of not locking resources & services for other client objects - a client object sends request to one of Stitie Spaces, then waits for response - perhaps on a concurrent thread as well. When a Distributed Stitie Space is synchronized (with other Stitie Space instances) & has available time for that, it just sends to a client object information it needs, or performs a service. Security Certificates & Privileges are considered as well.

Stitie Space Services might include:
- Communication between objects - for example when objects move often & when their coordinates change with time - when there are no proper long-range communication links,
- Handling requests to reform Space with MATEN or Prism functionalities,
- Establishing long-range communication links between client objects,
- Reserving destination Coordinates & Empty Movement Paths before a client object movement in space - for a given amount of time, at least.
- Updating coordinates registry in space after reaching destination by a client object.

See also, if You wish or need, ... : Agile Transformation of Information State.


Reasons behind 'Ola AH' Programming Language.

High-level Programming Languages allow for thinking abstractly - on a high level of abstraction - about solutions for problems to be solved by computers.

Mere library with extra semantics (meaning, use cases) for a language is often not enough, because elegant syntax (grammar, keywords) allows for simpler thinking, for acquiring paradigms (ways of perceiving & thinking), for acquiring idioms (good practices), for easier understanding of complex tricks & their use, for easier & faster coding.

With fewer lines of code there's less errors, programs are written, understood & maitained faster.

When reality changes, companies have to adapt & rewrite software quickly - preferably before competition releases their own competing products or services - high level programming languages are tools that give companies this advantage.

'Ola AH' Programming Language is fairly general-purpose language, but has found it's niches as well.


Stitie Space & Robot Swarm Concurrency.


One of use cases for 'Ola AH' Programming Language is for coordinating the robot swarms.

While not a language for the Real-Time Systems, 'Ola AH' can handle concurrency for such swarms well enough.

Communication & Leadership Hierarchy Tree.

Assuming that physical objects can fly in space, their coordinates can be transformed to a coordinating system that contains Stitie Space.

Physical objects form task groups under a leader machine, leader machines also form task groups with their own leaders ... up to the coordinating system with the Stitie Space.

Physical objects can communicate wirelessly using directional rays, to avoid the wireless communication collisions with so many objects. Messages reach their leaders, up to the coordinating system with the Stitie Space.

Coordinator - individual synchronization.

Messages from individual machines can reach coordinator machine by following the communication hierarchy tree. Messages are received by CommunicationSynchronizer object, then Stitie Space is updated.

Messages can be sent to the groups of individual machines as well, using the CommunicationSynchronizer object & the wireless communication (either a broadcast, a directional multicast or series of unicasts for example) - target machines know which parts of the code are addressed to them by their identifier.

Decision Precondition Events.

When a task group reaches it's objectives, then event can be fired by CommunicationSynchronizer object, also a SpaceAware machine can check its own coordinates in Stitie Space & fire events as well.

A precondition token is created in the ConcurrencyFlowGraph object as in the 'Token Game' & 'Decision Filters' articles.

With enough of tokens at proper places (for example, when all of the three task groups reach their targets) next decision can proceed.

Clock Deadline Events.

We can have a clock object which produces the clock events, and use these to control behavior of machines by sending messages wirelessly via the CommunicationSynchronizer object, to control the deadlines for individual physical objects.

A clock object can affect the precondition tokens existence in the ConcurrencyFlowGraphObject as well, to affect decisions made that way.

See also if You wish, or need, ... (including comments) : 'Ola AH': a Concurrent or the Real-Time Language?