1. Design Components are Code Components
There is no abstraction between Design Components and Code Components. Objects you design are directly made into code-Objects, called “Nodes”. No matter how complicated the Object-Node, its code is isolated and encapsulated to run at the lowest level of the CPU.
Knows How To
Designers
Design Component
I Know How To
Thread-Level Code
Programmers
Code Component

2. Automatically Instantiates
The Snippet Engine automatically instantiates all Object-Nodes when they are needed the first time. The programmer does not have to worry about how or when to get their Node into existence. Nodes may delete themselves when finished.
I Know How To
SnEn
I Know How To
Is Needed For First Time
Is Automatically Created
Nodes Exist Logically
Node Exists In RAM

3. Programmers Are Focused
Programmers are focused on only generating their Node’s code. They are coding a single CPU-Thread, independent and autonomous, to ensure a designed purpose is accomplished. Dependencies on other Nodes which must execute first are automatically handled by the Snippet Engine. Thus, the programmer's attention is directly focused on only the lines of code within their own execution Thread.
I Know How To
Knows How To
Code Component
Design Component

4. Same Interface Access Methods
All Nodes use the exact same Command Interface and Data Store access methods. All that the programmer needs to know is the format of the command packets and the data records, which are all defined during the Design Phase.
I Know How To
I Know How To
I Know How To
I Know How To
I Know How To
I Know How To
I Know How To
Commands In and Out
Data and State
Relationships
Interact
Interact
Interact
Interact
Interact
Interact
All Nodes Interact With Each Other The Same Way
Node Internals

5. Asserted Using Same Mechanism
Nodes have no calling sequence like a function. Nodes are ‘Asserted’ into execution, using the exact same mechanism. Asserting a Node to do its job is simple. This simplicity dramatically reduces the number of software interfaces that must be defined, programmed, tested, and documented.
All Nodes Are Asserted Into Execution The Same Way
Asserted
Asserted
asynchronous
asynchronous GO GO
CPU
CPU

6. Accomplished Asynchronously
Nodes are not called like a section of code, rather they are told to accomplish their task asynchronously. Nodes are Asserted because their designed purpose is required, and they may be Asserted in any order. Interdependencies between Nodes are automatically handled by the Snippet Engine.
I Know How To
I Know How To
I Know How To
I Know How To
I Know How To
I Know How To
Asserted
Asserted
Asserted
Asserted
Asserted
I Know How To
asynchronous
asynchronous
I Know How To GO GO
CPU
CPU
Node will wait for all pieces,
and then will Execute
Aggregated Results

7. Easy To Handle Ramifications
Variables are passed between Nodes by either sending commands, or by setting up a designed shared RAM context. Thus, the programmer is relieved of having to understand ramification complications when key values change. All a programmer needs to do is to “Post" the changes to the Node which knows how to handle the changes. Since the receiving Node is executed as a separate Thread, the programmer can literally “Post and Forget".
Asserted
Asserted
I Know How To
Commands In and Out
Data and State
Relationships
asynchronous
asynchronous
I Know How To GO GO
CPU
CPU
Post and Forget
Change The World
Oh! I changed the world!
Node will wait for all pieces,
and then will Execute
Aggregated Results

8. Can Fetch Data Directly
Nodes which need to fetch data from other local Nodes may do so directly, as an option, without posting commands. All Node’s Data reside in Shared RAM. Because Nodes both store and retrieve data in exactly the same way, the programmer uses a standardized code-template to directly fetch data from any other Node. If necessary, a Node's Data may be locked and then unlocked. This type of RAM coupling is very fast.
I Know How To
Commands In and Out
Data and State
Relationships
I Know How To
Commands In and Out
Data and State
Relationships
Data is coupled at nanosecond speeds

9. Reduced Number of Interfaces
All Nodes have only one State-variable, and this variable can have only five different values. This dramatically reduces the number of software interfaces, which dramatically reduces the number of test cases, which dramatically reduces the volume of documentation required in the project's life cycle.
With Typical
OOD Projects
With Snippet Engine OOD Projects
The More Interfaces and Choices
Only One Interface and 5 Choices
The More Complicated The Software
The Simpler The Software
The Heavier The Burden and Cost
The Lighter The Burden and Cost

10. Certified “Bug-Free”
Each Node can be independently tested, and most Nodes may even be certified to not have any bugs. The issue of code having hidden bugs is a result of not being able to test all software conditions. However, with Snippet Nodes, because they are narrow scopes of autonomous logic with their own data store, it is possible to isolate a Node's execution-context in order to conduct testing which will test all software conditions. Nodes may then be certified “bug-free”.
I Know How To
Commands In and Out
Data and State
Relationships
I Know How To
Certified
Bug-Free
Nodes Can Be
Tested For All
Software Conditions

11. Maintenance and Enhancements
Nodes are isolated and self contained, which lowers the cost of maintenance and future enhancements.

12. Previous Nodes Are On The Shelf Ready To Be Reused
Immediately Reusable
Most Nodes are immediately reusable in future projects. Thus, the cost of future software development projects is dramatically reduced.
I Know How To
Previous Nodes Are On The Shelf Ready To Be Reused

13. More CPUs The Faster Will Run
Nodes may execute on any available microprocessor. Since each Node is its own Thread of execution, the entire application may be massively solved in parallel by executing on computers with large numbers of microprocessors. The more available microprocessors, the faster the application will run.
I Know How To
I Know How To
I Know How To
I Know How To
I Know How To
I Know How To
Asserted
Asserted
I Know How To
asynchronous
asynchronous
I Know How To GO
CPU
More CPUs means more GO GO
CPU
CPU
Node will wait for all pieces,
and then will Execute
Aggregated Results

14. Node Integration Is “Automatic”
A new Node's integration into the application is “automatic”. There is no need for a separate Integration Phase. In order to thoroughly test a Node, the programmer must include all of the other Nodes needed. Programming is best performed starting with the lowest level Nodes, and working upwards. Thus, Nodes are being fully integration-tested each time a stand-alone-test is conducted.
I Know How To
Programming Is Done From The Bottom - Up
Aggregated Results
I Know How To
I Know How To
I Know How To
I Know How To

15. Faster With More Programmers
Because the project is developed from the bottom-up, and each Node is independently tested, the more programmers assigned, the faster the project will be finished. This allows the software managers to effectively manage the cost and delivery schedule.
I Know How To
Adding More Programmers Actually Helps
Programming Is Done From The Bottom - Up
I Know How To
I Know How To
Aggregated Results
I Know How To
I Know How To
I Know How To
I Know How To

16. Even Low-Level Nodes Use GUI
Any Node may use the application’s User Interface to interact with the user. Thus, even low-level code may have its own debugging, diagnostics, error reporting, and context help on the User Interface.
I Know How To
Aggregated Results
I Know How To

17. Any Node Talks To Any Node
Any Node may talk to and synchronize execution with any other Node, running anywhere in the world. Sending a command directly to a Node running on another computer is done the same way as sending a command to a local Node. This means that any execution Thread may directly communicate with any other execution Thread, even on a completely different computer. Creating applications that share synchronized data and aggregated capabilities between networked computers is very easy.
I Know How To
I Know How To
I Know How To
Internet
Aggregated Results
Nodes Can Send And Receive Commands and Data
To Other Nodes Running Anywhere In The World.
Nodes on Different Computers Can
Directly Synchronize and Aggregate Their Capabilities.
Essential for Games, Robotics, Mission Control, and
Distributed Databases

18. Nodes Are The Database Servers
Each webpage can communicate, via PHP, directly with any of the Nodes in the Network. Each Database Table interaction can directly and concurrently talk to that one specific Node managing the targeted Table. Thus, Database interactions are very fast.
These Nodes are Managing Database Tables
I Know How To
Aggregated Results
All Nodes Could Be Running on just one Laptop or
Each Node Could Be Running on its own Laptop

19. Aggregation of ‘Know How’
I Know How To
Aggregated Results
I Know How To
Aggregated Results
I Know How To
Aggregated Results
I Know How To
I Know How To
I Know How To
I Know How To

20. Aggregation of ‘Know How’
I Know How To
Aggregated Results
I Know How To
I Know How To
I Know How To
I Know How To

21. Aggregation of ‘Know How’
CPU
More CPUs means more GO
CPU
More CPUs means more GO
More Servers means more GO !
I Know How To
I Know How To
Aggregated Results
Aggregated Results
Internet

22. Aggregation of ‘Know How’
I Know How To
Aggregated Results
Be a Server
I Know How To
Aggregated Results
Be a Server
I Know How To
Aggregated Results
Be a Server
Infinity
Infinity
Internet