Forem: PhuirE Research

Stratimux is a Function as Operating System

RE||EK — Tue, 09 Apr 2024 15:57:04 +0000

Stratimux is a difficult framework to describe inherently. As it is very easy to go off an seemingly disconnected use cases of the approach. The design itself is meant to represent a baseline functional abstraction. As in a bare minimum, close to metal, method of computation that limits the direct overhead of higher abstractions that hide inefficiencies within our programs.

Its strange to think that so long ago we landed on the moon with computers that are less powerful than your smartphone. This was made possible via a form of computing that directly interacted with the data loaded on the computer, rather than having to rely on a brittle complex rats nest of abstractions that we have today. Ever wonder why majority of applications are so buggy out of the box and is just something we expect?

Stratimux is a Baseline Abstraction

To resolve this Stratimux is formalized as a baseline abstraction, but despite the overall simplicity. Programs written in this format quickly grow in complexity. Not only is it difficult to write strategies within the paradigm due to their branching nature and the linear nature of code, but the core of this decision allows for each strategy to exist in most efficient form. Or the quickest path of programs execution as a baseline due to the nature of N Trees and graphs in computing.

In addition the core of the application itself being designed to have many different graphs(strategies and plans) running concurrently on the same thread. By default this allows for the system of design to be inherently multi-user out of the box. Not to mention the interaction with the overall internet, blurring the line between your PC/smartphone and the servers you unknowingly interact with.

One of the many reasons for this design was to solve a life long frustration with computers. That you could have a calculator open on one part of the screen and a spreadsheet on the side of it. The traditional workflow of working with the two is to copy and paste the outputs of the calculator into the spreadsheet. But why do you need to copy and paste in the first place? Why not have the calculator automatically fill in that cell on the spreadsheet without having to copy and paste? Why can you not have a cell that is calculating some value, and have that same formula plugged in on the calculator, ready for you to play with?

A Lifelong Frustration

This represents a strange break of communication between our applications. Where the transitive integration between applications is some manual process of work. Despite all these calculations being made on the same machine, there isn't an intuitive interface, or for the programmers reading this. API that automatically allows you to script interactions between applications and formalize an automated workflow. You can create such a thing, but it exists as some glue code that can break on the next update, rather than a fully integrated system.

What if instead of wanting to just have all of your applications existing as some workflow, instead have it so that the applications themselves could formalize a new application entirely for their connected parts. A new UI existing on top that formalizes such as a stand alone program, but underneath you can observe the complex interactions between these previously disconnected parts of your operating system.

The Foot of the Mountain

In effect Stratimux as a system of design and an MVP of a new class of Operating System, that allows for not only orchestration of applications together as a single point of entry. But the ability to unify, remix, and compose entirely new applications. Where each emergent application, becomes a new part that can be orchestrated within the whole of your operating system. As each separate app, in all technicality is its own operating system. With no need for virtualization and functional out of the box.

This is made possible due to traditional applications are instead represented as stand alone concepts. Where each instance of Stratimux, loads those applications as part of a set. And formalizes a means of communication via a shared interface via the ActionStrategy pattern. Point to point, part to part communication. Meaning you can have the formula from the spreadsheet be inputted into your calculator and the output of the new formula that you are interacting with provide its output to the spreadsheet.

Recently I've completed a major update to Stratimux that completely changed to core logic allowing for the overall system providing a 2x speed boost. What is interesting about this update, is that the overall abstraction did not change, only the core logic itself. Meaning this update presented a strange proof, that the entire system exists as a strong MVP right now. Can become completely responsible for itself, with all parts written and translated into a low level representation with minimum effort. Eventually taking full responsibility for even the Kernel, allowing for Stratimux to be not just an application, but a fully integrated Operating System.

Stratimux is a Unified Turing Machine that solves the impossible halting problem of the classic, that goes further than any other Operating System on the market. The issue with marketing, is that it can represent a website, a game engine, even an artificial intelligence, and anything that can be written for our machine to actualize into an interactive medium.

That can smash entire programs into one another and remix them to suite your personalization. AI just makes the approach seamless once fully integrated and beyond a level of complexity. In effect formalizing a direct representation of Science Fiction's Cyberdeck, and Cyberspace. But realized instead as the "Conceptual Deck," and interaction between such as, "Conceptual Space." It's just limited to DOS-like format for the time being, but still constitute a massive technology unlock that affords for an unlimited exploration of a compounding combinatory exponential space.

Stratimux @ Github

Higher Order Reasoning / Hierarchical Planning

RE||EK — Mon, 11 Mar 2024 14:11:57 +0000

In a recent interview with Yann Lecun, it was highlighted that one of the major weaknesses of modern LLMs is hierarchical planning. That the recent effort of top labs have moved towards handling some concept space in combination with attempting to have LLMs reason about some plan to accomplish an A to B process.

The difficulty in the respect is that Higher Order Reasoning is something that is not traditionally written down. That despite it being something that we as humanity do day to day without thinking about it. Is likewise the greatest weakness of AI as of early 2024, fits to the data distribution that would be available for training.

As what Higher Order Reasoning would amount to within an organization with be some trade secret or tribal knowledge that is the secret to that organizations success. So where would this data come from, if LLMs are constrained towards knowing what is within their data set? One practice has been to have users list out their strategies to attempt to extract out this reasoning process.

The difficulty in extracting out this data through indirect means does not respect the total difficulty that hierarchical planning imposes. As not only does the problem space increase in difficulty exponentially upon each successive step in executing some plan. It likewise is magnified by some combinational aspect based on the concepts known to the practitioner.

Via this organizations graph programming framework, Stratimux, we have broken down this problem space into a series of slices to decrease the difficulty of creating this high quality data.

This work is based on a NPM package written by this author in 2018 referred to as the ActionStrategy. Which is simply a binary tree of possible actions that can be used to accomplish the goal of the described strategy. Specifically that was made to chart applications, as ultimately all programs revert back to some stack trace when they run into an error. Therefore why not be explicit in these deeply embedded relationships obfuscated by our programs?

The reality is that handling these strategies are simple in a single domain. And for all intensive purposes the framework is ready for production in a limited scale of complexity. The difficulty with the direct approach of mapping the internals of our applications. Is a back pressure problem present when multiple strategies are running concurrently. But likewise demonstrates a new avenue of formalizing algorithms, beyond that of the manipulation of data structures.

Therefore the utilization of Stratimux, is meant not just for the creation a new class of applications. But applications that likewise are designed to be utilized as training data to inform Higher Order Reasoning, or as the Artificial Intelligence field understands such: Hierarchical Planning.

Apologies for the brief introduction to this problem space. In the coming months there will be more information by way of tutorials, examples, and even an LLM fined-tuned with this information to interact with. Till then, be safe, and have fun!

Base Complexity

RE||EK — Mon, 11 Mar 2024 13:35:01 +0000

Base Complexity is a new proposed measurement to account for the total complexity of a given application, framework, or graph of connections. In contrast to Big O notation, this is examining the complexity of state mutations of an application across a series of steps. It is interesting to not that in regards to the default complexity of all applications to this point is just some Base 1. Where Base 0 would be the block scope mutation of some variable.

Whereby there is a function or method that modifies some state by way of a single time sequence. Game AI have traditionally been some Base C 1-2, as this accounts the number of actions that are accounted for in some sequence. Where any string of actions greater than 2, would introduce side effects into other systems.

As the true difficulty of this notation, is that it highlights the exponential complexity of an application per additional step involved in a sequence. That if there is some grand strategy that is engaged in a system that involves a specific value to remain locked. Eases the difficulty of devising these sequences.

As an analog to daily life would be the ride share. That you and some partner or friend might share the same car. That your strategy for the day directly involves the location of that car within a network and if you are the one who is picked up. Your strategy for that day must likewise account for the possibility of that car being in some accident or late. In which there would be a new set of strategies engaged by both parties. In order to shift back to the original optimum routine. This Complexity is some Base C 2 + N, for the Scope of getting to work then out. The Complexity of any additional strategies given a car being in an accident would is that N, as in discovery and unknown due to not knowing the degree of the accident itself.

But let's say that the accident totals the car and there is no passenger harm. For the one who is late, the strategy is Base 1 for ride share. But the shared strategy is some Base C 3 for the scope of managing the original strategy, rental, and eventual new ownership of a car. But the purchase of the car itself is its own complexity that is entirely dependent upon the specifics of this situation. So it would be some Base C 3 + N. In the most ideal there is no accounting for credit check, you have full funds to place a down payment, and there is little decision making in the process. So the the total complexity is just Base 3 N where N = 1 or Base 3.

Where this methodology would be most important in computer science. Would be within cloud networking, or the movement of data across a series of edge points to be closest to the user. Where the main difficulty presented in the cloud is the update to the user's data, in combination with maintaining an updated edge point for that user. But even when we examine this complexity, it is still just some Base C 2 + 2. Whereby you move the data to the edge, render such on their screen, then update the record from origin, that then cascades that data to edge. Where the complexity begins is after the data is transferred to the user. As up to this point, all data mutations are entirely within a Base C 2, but accounts for the moment the user connect likewise adds a factor of 2 to enable interactivity with that user's data. Thus Base C 4. This demonstrates how Base Complexity highlights that potential of a value being out of date or any data races depending on your edge update strategy.

This is important to recognize as the majority of what we do has been limited to a baseline complexity of 1. That we move some data, to a user, and the user updates some table on your server. That the consequence of allowing multiple participants to be factored into a distributed system to edit a series of data in some tables. Should account for the total increase of steps (especially off network) and not just the exponential nature of a single step.

The true reason for this introduction is likewise a measure in which we can judge some code that an AI might create. And whether such is capable of halting, as the unfortunate side effect of potential data races in a complex environment. Is the potential of passing the same value back and forth stuck in an infinite loop. As this can likewise be pushed into a broader measurement of any models ability to reason within some Base Complexity. While highlighting that the standard complexity of what we engage in is just some Base C 1, but take for granted the difficulty of managing a ride share.