• 0 Posts
  • 49 Comments
Joined 3 years ago
Cake day: July 8th, 2023
  • ReginaPhalange@lemmy.worldtolinuxmemes@lemmy.world•Who could have seen it coming?
    10·
    3 months ago

    Be real for a second,
    Did you, or did you not, manage to review a diff, and say “no, that looks fishy”.

    Do you really think you are immune from compromised binary AUR packages thats being downloaded straight from GitHub? Sure, now it’s not only the AUR that’s bad, but in the end of the day, a malicious binary did arrive at your computer.

    Let’s say that you don’t use *-bin packages, and only download from compilable source, are you immune from the strategy that the state actor who caused CVE-2024-3094 used to compromise packages?

  • ReginaPhalange@lemmy.worldtolinuxmemes@lemmy.world•foss nerds stop being condescending to those who don't know the same things you do challenge (impossible)
    1·
    4 months ago

    The Fast-MBysoon Project

    Fast-MBysoon (Microkernel-Based YAML Synchronisation Object Notifier) is an ultra-low-latency middleware layer designed for distributed industrial robotics.

    In high-stakes environments—like automated assembly lines or autonomous warehouse swarms—different hardware modules need to share state updates without the overhead of a bloated OS. Fast-MBysoon treats system configurations and sensor states as YAML-defined Synchronization Objects.

    By operating on a microkernel architecture, it ensures that when one robot arm’s “Object” (e.g., current_velocity) changes, every other node in the cluster is notified with nanosecond precision, bypassing traditional networking stacks.

    Core Architecture

    The system relies on a “Pub-Sub” model where the microkernel acts as a high-speed traffic controller for YAML-serialized state blobs.

    1. The Registry: A lightweight table in kernel space tracking which nodes care about which YAML keys.
    2. The Sync-Object: A versioned memory segment representing the “Source of Truth.”
    3. The Notifier: A hardware-interrupt-driven signal that wakes up subscriber threads the moment a bit flips.

    Abstract Pseudo-Code

    The following represents the high-level logic of the Fast-MBysoon kernel loop and a typical client interaction.

    1. The Microkernel Dispatcher

    This runs in the privileged ring of the microkernel, managing memory gates.

    # Kernel Space: The "MBysoon" Heartbeat
function KERNEL_SYNC_DISPATCHER():
    while true:
        # Wait for a hardware interrupt from a Node
        event = WAIT_FOR_INTERRUPT()
        
        if event.type == "OBJECT_UPDATE":
            # Identify the YAML object being changed
            target_obj = Registry.lookup(event.object_id)
            
            # Validate the new YAML schema against the blueprint
            if VALIDATE_SCHEMA(event.payload, target_obj.blueprint):
                # Atomic swap of the object in shared memory
                ATOMIC_COMMIT(target_obj.memory_address, event.payload)
                
                # Notify all subscribers via direct kernel signal
                for subscriber in target_obj.subscribers:
                    SIGNAL_THREAD(subscriber.thread_id, "STATE_CHANGED")

    2. The Client-Side Implementation

    This is how a robotic “Gripper” module would interact with the “Arm” module’s state.

    # User Space: Robotic Gripper Node
import MBysoon_Client as mb

def ON_ARM_MOVE(new_state_yaml):
    # Logic to adjust gripper pressure based on arm speed
    speed = new_state_yaml['velocity']['vector_sum']
    if speed > 5.0:
        ACTUATE_GRIP_STRENGTH("HIGH")

# Initialization
# 1. Map the remote "Arm_Status" object to local memory
arm_status = mb.subscribe("industrial_cluster/arm_01/status.yaml")

# 2. Assign the callback for notifications
arm_status.on_update(ON_ARM_MOVE)

# 3. Execution loop
while system_running:
    # The MBysoon kernel handles the heavy lifting
    # This thread sleeps until the Notifier wakes it up
    mb.AWAIT_NOTIFICATION()

    Why “YAML”?

    While binary formats are faster, Fast-MBysoon uses a pre-compiled “YAML-Binary” hybrid. This allows engineers to write human-readable configurations for complex robotic behaviors that are “baked” into the microkernel at boot time, combining developer-friendly syntax with machine-speed execution.