Stitie Processor model.

This is only feature list, not technical documentation: (see rest of the blog and code for details)

I've designed some classes. Strategy implementing processor instruction jmp, to coords (x,y,z). Memory is cube addressed by coords (x,y,z). That is, this is 3d graph processor.

Object oriented processor might seem slow, but only if standard solutions are used. With proper design of hardware, new possibilities unfold. We can model reality faster, software is cheaper to develop, for on very low level it reflects programming language. No more tedious translations from language to language and again..

There's ALU (Arithmetic-Logic Unit), node where data meets with code, and where it is executed. It's also called 'processing unit' (this is alternative definition to ALU).

There are 12 general purpose registers (Reg0 ... Reg11) around processing unit, Instruction Pointer Register (Ipr), inside processing unit (for security and speed). It works on coords. There's also Clock Register (Creg).

You can see code: stable and unstable connection (it's graph not svn tree), comments and questions are welcome.

I've decided to allow for low level tricks without any security harness. This means that low level programmers will be able to design any MachineForm. Later there will be higher level programming language (for final product), called 'Ola', because it is too expensive to program everything in low level language. 'Ola' language will have 'Ah' level (Anti-hack). There will be Ah instruction for assembler code, which will allow for proper tools design.

Pi Number will be counted from equation:

2/Pi = (sqr(2)/2) * (sqr(2+sqr(2))/2) * ...

We'll create Finite State Automaton in 3D in Stitie Space, then iterate.

We'll use Object Oriented Notation of Numbers for this. See this post.

We'll count square root (sqr) using Newton's Method. I'll need to investigate this method properly (as part of this exercise) and implement this code in Java and Go and Ola independently.

There will be support for Groups and Bodies, so Pi number can be counted using higher algebra, perhaps more efficiently than using simpler methods.

(removed requirement for strange State organization... it's too complex, bizzare, slow and expensive).


* Splitting and joining information flow (see this post in this blog). It will be optional. In processor it can be used to send register state (value) or mnemonic (code can also be represented as value, or state) to processing unit (ALU, or place where code meets with data and is executed).
* There will be MATEN mnemonic, from 'Matrix Enhanced'. It will speed up processor instructions and flow information from registers at cost of other operations and registers. In runtime.) How it will work? There will be reorganizable topology of nodes and connections. MATEN will invoke certain forms (see this post and this post). This Method is called polyformic programming (it's something different than polymorphic programming, but not opposite). There will be transition function (method) that will transform one Machine Form into another. There will be Machine Form called Default Machine Form but it would not be mandatory to use it as transitory stage. This way we'll avoid bottlenecks (there can be faster transformations).
* Researching Mathematical instructions. See this post and this post.
* Researching Randezvous/Petri Net concurrency system. Multiple processes do something, then send tokens with results (partial or not) that are joined at join node. When join node finishes collecting all tokens (also called preconditions) it can join them in complete result and program can proceed. It's similar to Petri Net Transition Node behaviour but not neccessarily the same.
* Researching inner and outer layers, connected with interface points. It's used for 3d polymorphism and perhaps more (see this post). Outer layer contains subclasses, outer layer space is partitioned, each part contains subclass.
* Researching Jne mnemonic.
* Integrating Memory Adressing into MachineForm.
* Adressing state (done what's required for Jne).

Mathematical operations supported:

* computing sine (see this post).
* computing PI number.
* more to come later (for sure).


* Jmp mnemonic. ( jump to 3d coords: to (x,y,z), not to address pointed by spherical angle. )
* Clock. (first try)
* Registers in 3D (close to processing unit).
* Modified Direction enum to use sane names.
* Routing information from Registers in 3D, not via single bottleneck array. Routing via different nodes can be done as needed.
* Jump if Not Equal mnemonic (Jne). Reconsidering mnemonic name for bcr [basic conditional redirect], because of Higher Algebra and 3d space. It's still conditional jump instruction. See also: this post.
* Basic Unicode support (UTF-32 only).
* ROT mnemonic.
* Maneuvers, that will be used in MATEN mnemonic.

Arithmetical / Logical mnemonics done:

* Add. (add long integers)
* Mul. (multiply long integers)
* Addp. (add arbitrary precision numbers. implemented operation with 3d coords.)
* Mulp. (multiply arbitrary precision numbers. implemented operation with 3d coords.) See: this post.


Arithmetical / Logical mnemonics to be done:

* Addc. (add arbitrary precision numbers, changing base in process)
* Mulc. (multiply arbitrary precision numbers, changing base in process)
* Nbc. (number base change)

(... much more ...)

Need to use proper number notation, see this post. Note that arithmetical operation will depend on numbers being witten in the same form, more precisely, use the same base. For example, to add number written as base-2 number to number written as base-10 number, one of these numbers must be converted to other form. That is, both must have same base. Most supported types will be: base-2, base-3, base-4, base-6, base-8, base-10, base-12, base-16, base-84 and base-108.

Other things to do:

* Adressing state (done what's required for Jne). See this post.
* Logical and Mathematical mnemonics. Including Geometry with Linear Algebry, somehow. Including Matrix computations. See also: this post.
* 'Blum Blum Shub' Random number generator (first try). See also: this post.
* Basic concurrency support.
* Considering using reflection as part of processor services.
* Regular Expressions.

Feature list closed for this exercise. Perhaps in next it will be more or less, or differently.

This exercise and everything related is for Her, she can do anything she wishes or as she pleases. Sell, use, scrap, anything. Talk with her if you want to use it. Wherever she is.

Planned for future (not for this exercise):

* Complementary Forms. Arithmetic-Logic Unit (ALU), or point from which Form originates can have complementary Forms nearby. Forms can communicate with each other, independently from ALU. ALU will oversee and recreate missing forms. There's possibility for using multiple ALU. Communication with ALU is single-directional (from ALU to Complementary Form). This is just one of many possible ways of thinking, solutions. Complementary forms paradigm. Please note that ALU (seed of system, this is perhaps new meaning of word ALU) can move, and that objects can have aspects, including security aspects.

More information will be added later, perhaps.

Deadline for this project was: 06.06.2015, now is cancelled.


Complex Languages

The more expressive (and often more complex because of that) programming language is, the more tricks can be used to optimize code on low level. It takes years of practice and expertise to understand language so well. Let's think about the cost. Worst is maintenance, as more expensive crew needs to be hired to maitain such expert level code.

What to do about it? Let's define expertise levels and put them in syntax.

It allows business to plan costs of maitaining code.

With experience anyone can learn any language expertly and earn privilege to maitain more challenging code, and better salary for this ordeal.


Counting sine using Taylor Serie.

Formula is:

sin x = x - (x^3 / 3!) + (x^5 / 5!) - (x^7 / 7!) + ... =

= sum ( (-1)^n * (x ^ (2n+1) ) / (2n + 1)! )

Processors should be able to count sine, even in virtual machine.

In processor some values should be precalculated for speed.

There can be even dynamic cache used. It means that most popular values will remain. Along with some predetermined (strategic).


Complete Objects.

In general, an object is complete if nothing needs to be added to it. This notion is made more specific in various fields. See also 'final' keyword in java.


Aspect Oriented Programming & AspectJ

The motivation for AspectJ (and likewise for aspect-oriented programming) is the realization that there are issues or concerns that are not well captured by traditional programming methodologies. Consider the problem of enforcing a security policy in some application. By its nature, security cuts across many of the natural units of modularity of the application. Moreover, the security policy must be uniformly applied to any additions as the application evolves. And the security policy that is being applied might itself evolve. Capturing concerns like a security policy in a disciplined way is difficult and error-prone in a traditional programming language.

Concerns like security cut across the natural units of modularity. For object-oriented programming languages, the natural unit of modularity is the class. But in object-oriented programming languages, crosscutting concerns are not easily turned into classes precisely because they cut across classes, and so these aren't reusable, they can't be refined or inherited, they are spread through out the program in an undisciplined way, in short, they are difficult to work with.

Aspect-oriented programming is a way of modularizing crosscutting concerns much like object-oriented programming is a way of modularizing common concerns. AspectJ is an implementation of aspect-oriented programming for Java.

How to use AspectJ?

Def. A join point is a well-defined point in the program flow.

Def. Join points compose into pointcuts.

Def. Advice, the code which is run when a pointcut is reached.

Def. Pointcuts and advice combine into aspects, AspectJ's reusable, inheritable unit of modularity.

Def. Inter-type declarations in AspectJ are declarations that cut across classes and their hierarchies. They may declare members that cut across multiple classes, or change the inheritance relationship between classes. Unlike advice, which operates primarily dynamically, introduction operates statically, at compile-time.

Inter-type declarations are used to deal with crosscutting concerns of a program's class structure.