Forem: RE||EK

My OS can do Somethings yours Cannot

RE||EK — Fri, 19 Apr 2024 23:10:29 +0000

The classic OS we all use and even the layer allow for Stratimux to exist as an MVP. It can run any application, including a prototype of a new emerging paradigm. Classically this would be referred to as a Universal Turing Machine that is capable or running any computation variant. When put to the test however, this ability is something that is merely good enough, or in general it can run any computation, until you find the wall for what was supposed to be a boundless computation environment.

One design decision that contrasts your OS in comparison to my own. Is that all calculations have some timer attached to them. This is done to ensure that operations must always conclude allow you computer to keep running uninterrupted. But this mechanism isn't perfect, and people can create their own code that unintentionally triggers a broader impact across the system.

What if you wanted a loop to always be running in the background? In our current paradigm of computing you would have to create a sophisticated event loop to ensure that you can pause this operation, modify it as needed, and close if your program exits. In fact this is the current mechanism used within Stratimux to ensure that long running processes such as an indefinite loop may halt, without the utilization of a timer.

What if you wanted an indefinite loop, but needed it to run continuously and pick up where it left off so long as the process is active? Or if you wanted that loop to be saved at its current iteration and when the program exits? If you could freeze an application prior to hitting a system error. Then hand it directly to a colleague to help you find the solution, initializing just prior to the error. And all you had to do was open a file associated with that error.

What if loops were simply bad design?

In modern programming languages there is a strange dynamic that may now be pointed out. That the alternative to this approach, the Recursive Function, is often times exchanged for a loop on the backend. Yet each step of a loop is merely some function. As the two approaches interchangeable, except the loop blocks the current thread. Alternatively we can use a functional approach, first by creating a greater recursive function. Where the logic of the loop is translated into a recursive function controlled by the greater. Therefore each step of the loop is just one step of the greater recursive function and is non blocking, but still loops.

The most basic loop, the while. Is just a function that recalls itself so long as a condition is true. Next would be the for loop, but it provides an additional interface that automatically iterates some value, to control when the loop concludes. Since all loops can be replaced with recursive functions, each iteration of the loop is just a function, but represented as a code block. We are now able to highlight the while loop is an arbitrary function or symbol. This logical inconsistency is the the reason why the halting problem in the Turing Machine exists in the first place.

To eliminate this critical vulnerability in the scope of AI, we can replace the while loop with a recursive function, that accepts a condition and a halting pointer. If an ASI is larger by proportion than an AGI, the ASI would have a greater likelihood of being stuck in an Infinite Loop, despite the slim chance of such in isolation. For example how mainframe computers need to take into account sun spots due to scale, but home PCs can throw out the issue entirely.

Following the same line of logic, there isn't a reason to ring any alarm bells for the general population. But instead can focus laser targeted effort at the most critical areas of our infrastructure. Such the creation of an AI running logging operations would be a prime candidate to have to have the halting issue resolved entirely.

Thus, the reason why my operating system can do something yours cannot. Is that the logical consistency for its operation was inspired by the frustration of running into limitations with the classic. The ability to halt a computer system, cease all operations and then resume as if nothing had happened. Even when transferring between different devices, is merely consistent logic that supports that dynamic. Discord on my own PC has a habit of requiring myself to force quit the application each time I wake my computer if I want to use it. Is just the poor application of consistent logic in the larger context of computing.

Granted the above would be the low level implementation of Stratimux once it moves from MVP. The most important aspect of this design pattern. Is that each part of it, can be translated from high level, to low level representation. Meaning we can have a form of backwards compatibility with the classic OS. The intent of this next OS paradigm, would be one that takes into account all lessons we have learned at this point of computing. But this is the larger picture and far away right now.

Stratimux proposes a new interface for managing what we call loops. The Plan.

const plan = axium.plan('Count to 5', [
    createStage((concepts, dispatch) => {
        const count = selectState<CounterState>(concepts, counterName).count;
        if (count && count <= 5) {
            dispatch(addOne(), {
            // Stops the stage delimiter from concluding the stage
                thottle: 0,
            });
        } else if (count) {
            console.log('Counted to 5', count);
            plan.conclude();
        } else {
            console.log('Counter removed from axium');
            plan.conclude();
        }
    })
]);

In contrast to the original while loop:

let count = 0;
while (count <= 5) {
    count++;
}
console.log('Counted to 5', count);

While the plan has more code, it is likewise is fully responsible for its implementation as a framework. If we were to create our own backend, while allowing for type information to be directly integrated into the logic. We could have something like this:

plan [
    stage {
        const {count} = select<Counter>();
        if (count <= 5) {
            dispatch(addOne(), {
                thottle: 0,
            });
        } else {
            conclude(log('Counted to 5: ' + count));
        }
    }
];

The above would be a minimum while remaining verbose. Noting we are determining plan, stage, dispatch and conclude as a keywords. Then assuming that the select is receiving the most recent concepts, removing the need to always mention such. The plan can likewise iterate through its stages, allowing for greater control over your applications logic.

Despite the example above, a plan is mainly used to dispatch entire strategies. Becoming an effective tool towards the manipulation of graph slices to formalize truly dynamic run times that are not possible in the current Turing Machine paradigm. But may be written in one.

There we have it, a halting loop that is able to remain consistent with the rest of the application. Not only that, each part of the application may be allowed access to the shared count value. This is what makes the Unified Turing Machine non-linear, and by side effect a Function as Operating System. As one of the greatest things my OS can do that yours cannot, is to allow another program reference this count value. While allowing for either to define the logical consistency of this interaction.

While this approach to programming has greater complexity than your traditional linear approach. This dynamic was created to allow for the entire scope of our applications to be mapped in such way, that we can reconfigure those parts into new applications. Or even allow our application to be unified together to create a new emergent application based on the prior. Just another super power this FaaOS can perform natively, in contrast to the classic.

My OS can do Somethings yours Cannot

RE||EK — Fri, 19 Apr 2024 23:10:29 +0000

What if loops were simply bad design?

Stratimux proposes a new interface for managing what we call loops. The Plan.

const plan = axium.plan('Count to 5', [
    createStage((concepts, dispatch) => {
        const count = selectState<CounterState>(concepts, counterName).count;
        if (count && count <= 5) {
            dispatch(addOne(), {
            // Stops the stage delimiter from concluding the stage
                thottle: 0,
            });
        } else if (count) {
            console.log('Counted to 5', count);
            plan.conclude();
        } else {
            console.log('Counter removed from axium');
            plan.conclude();
        }
    })
]);

In contrast to the original while loop:

let count = 0;
while (count <= 5) {
    count++;
}
console.log('Counted to 5', count);

plan [
    stage {
        const {count} = select<Counter>();
        if (count <= 5) {
            dispatch(addOne(), {
                thottle: 0,
            });
        } else {
            conclude(log('Counted to 5: ' + count));
        }
    }
];

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.