<?xml version="1.0" encoding="UTF-8"?>
<!-- generator="FeedCreator 1.8" -->
<?xml-stylesheet href="https://doc.seolizer.de/lib/exe/css.php?s=feed" type="text/css"?>
<rdf:RDF
    xmlns="http://purl.org/rss/1.0/"
    xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
    xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
    xmlns:dc="http://purl.org/dc/elements/1.1/">
    <channel rdf:about="https://doc.seolizer.de/feed.php">
        <title>SEOLizer Dokumentation - lyx_-_programmiersprache</title>
        <description></description>
        <link>https://doc.seolizer.de/</link>
        <image rdf:resource="https://doc.seolizer.de/_media/wiki:dokuwiki.svg" />
       <dc:date>2026-05-25T13:16:25+00:00</dc:date>
        <items>
            <rdf:Seq>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:abi-calling-conventions?rev=1779454198&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:aerospace-safety?rev=1779466785&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:aerospace-tutorial?rev=1779439722&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:arrays-datensammlungen?rev=1779466347&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:arrays-maps?rev=1779466364&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:attributes-pragmas?rev=1775545511&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:compiler-parameter?rev=1779454787&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:das-energy-aware-programmiermodell?rev=1779444200&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:data?rev=1779437631&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:datentypen?rev=1779454471&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:dedingungen?rev=1779467710&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:do-178c?rev=1779466828&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:erste-schritte?rev=1779445083&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:exception-handling?rev=1779467645&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:ffi?rev=1779446943&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:funktionen?rev=1779459103&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:generics-traits?rev=1779443772&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:lyx-compiler-selbst-kompilieren?rev=1779447519&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:memory-management?rev=1779449047&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:ml?rev=1779441008&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:oop?rev=1779449576&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:pattern-matching?rev=1779467686&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:pointer-inlining?rev=1779450956&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:rekursion?rev=1779451985&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:rtos-embedded-concurrency?rev=1779460287&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:schleifen?rev=1779453187&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:syntax?rev=1779459202&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:threads-nebenlaeufikeit?rev=1779460333&amp;do=diff"/>
                <rdf:li rdf:resource="https://doc.seolizer.de/lyx_-_programmiersprache:units?rev=1779523886&amp;do=diff"/>
            </rdf:Seq>
        </items>
    </channel>
    <image rdf:about="https://doc.seolizer.de/_media/wiki:dokuwiki.svg">
        <title>SEOLizer Dokumentation</title>
        <link>https://doc.seolizer.de/</link>
        <url>https://doc.seolizer.de/_media/wiki:dokuwiki.svg</url>
    </image>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:abi-calling-conventions?rev=1779454198&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T12:49:58+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – ABI &amp; Calling Conventions</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:abi-calling-conventions?rev=1779454198&amp;do=diff</link>
        <description>Lyx – ABI &amp; Calling Conventions

Die ABI (Application Binary Interface) legt fest, wie Funktionen auf Binärebene kommunizieren: welche Register Argumente tragen, wie der Stack aufgebaut ist, wer Register sichert und wie der Rückgabewert transportiert wird. Lyx folgt den nativen Konventionen der jeweiligen Zielplattform, um Kompatibilität mit Betriebssystem-Syscalls und C-Bibliotheken ohne Wrapper zu gewährleisten.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:aerospace-safety?rev=1779466785&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T16:19:45+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Aerospace &amp; Safety</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:aerospace-safety?rev=1779466785&amp;do=diff</link>
        <description>Aerospace &amp; Safety

Lyx wurde von Grund auf für den Einsatz in sicherheitskritischen Systemen entworfen. Die Sprache und ihre Toolchain richten sich nach DO-178C — dem primären Standard der Luftfahrtbehörden EASA und FAA für die Zertifizierung von Avionik-Software. Viele der Sprachentscheidungen, die auf den ersten Blick wie bloße Stilwahl wirken — explizite Typisierung, kein Garbage Collector, vier Speicherklassen, Range-Typen — sind direkte Konsequenzen dieser Zieldomäne.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:aerospace-tutorial?rev=1779439722&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T08:48:42+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Aerospace Tutorial: Von der Anforderung zum Nachweis</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:aerospace-tutorial?rev=1779439722&amp;do=diff</link>
        <description>Aerospace Tutorial: Von der Anforderung zum Nachweis

Dieses Tutorial führt Schritt für Schritt durch den vollständigen Entwicklungszyklus eines sicherheitskritischen Lyx-Programms — von der Projektstruktur über das Schreiben von Safety-konformem Code bis hin zur Erzeugung aller Zertifizierungsnachweise nach DO-178C.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:arrays-datensammlungen?rev=1779466347&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T16:12:27+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Arrays, Maps &amp; Datensammlungen</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:arrays-datensammlungen?rev=1779466347&amp;do=diff</link>
        <description>Lyx – Arrays, Maps &amp; Datensammlungen

Lyx unterscheidet vier Container-Formen. Die Wahl zwischen ihnen ist keine Stilfrage, sondern eine Sicherheits- und Architekturentscheidung: Stack-Arrays sind deterministisch und DO-178C-tauglich, Heap-Arrays sind flexibel aber nicht echtzeitfähig, SIMD-Arrays für numerische Hochleistungsberechnungen, Maps für Schlüssel-Wert-Zugriff.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:arrays-maps?rev=1779466364&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T16:12:44+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Arrays &amp; Maps</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:arrays-maps?rev=1779466364&amp;do=diff</link>
        <description>Lyx – Arrays &amp; Maps

Diese Seite wurde mit Arrays, Maps &amp; Datensammlungen zusammengeführt.

→ Arrays, Maps &amp; Datensammlungen — vollständige Dokumentation</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:attributes-pragmas?rev=1775545511&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-04-07T07:05:11+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Attribute &amp; Pragmas (@-Referenz)</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:attributes-pragmas?rev=1775545511&amp;do=diff</link>
        <description>Lyx – Attribute &amp; Pragmas (@-Referenz)

In Lyx werden Metadaten und Compiler-Anweisungen über Attribute (auch Pragmas genannt) gesteuert. Sie beginnen immer mit einem @-Zeichen und können auf Units, Funktionen oder Variablen angewendet werden.

1. Sicherheits- &amp; Integritäts-Attribute</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:compiler-parameter?rev=1779454787&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T12:59:47+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx Compiler – CLI Referenz</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:compiler-parameter?rev=1779454787&amp;do=diff</link>
        <description>Lyx Compiler – CLI Referenz

Der Lyx-Compiler (lyxc) ist ein moderner Cross-Compiler für Linux, Windows, macOS und Embedded-Systeme. Er kombiniert Compiler, Linker und statisches Analyse-Werkzeug in einem einzigen Binary.

Aufruf-Syntax



Flags können in beliebiger Reihenfolge angegeben werden. Kurzformen (</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:das-energy-aware-programmiermodell?rev=1779444200&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T10:03:20+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Das Energy-Aware Programmiermodell</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:das-energy-aware-programmiermodell?rev=1779444200&amp;do=diff</link>
        <description>Lyx – Das Energy-Aware Programmiermodell

In batteriebetriebenen Systemen, Embedded-Knoten und Rechenzentren ist Energie eine knappe Ressource. Maximale Rechenleistung ist nicht immer das Ziel — oft ist „Performance pro Watt“ die entscheidende Größe. Ein Temperatursensor, der alle 10 Sekunden misst, muss keine AVX-512-Instruktionen nutzen. Ein Kryptographie-Kern auf demselben Chip hingegen schon.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:data?rev=1779437631&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T08:13:51+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>data/ — Lyx Data Library</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:data?rev=1779437631&amp;do=diff</link>
        <description>data/ — Lyx Data Library

Pandas-ähnliche Datenanalyse-Bibliothek für Lyx. Die data/-Units sind eigenständig vom std/-Namespace und werden separat importiert. Sie richten sich an Datenanalyse, ETL-Pipelines, maschinelles Lernen und statistische Auswertungen — mit native Lyx-Implementierungen ohne externe Abhängigkeiten.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:datentypen?rev=1779454471&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T12:54:31+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Datentypen</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:datentypen?rev=1779454471&amp;do=diff</link>
        <description>Lyx – Datentypen

Stand: v0.9.0

Das Typsystem von Lyx ist explizit und statisch: Jede Variable hat einen festen Typ, der zur Compile-Zeit bekannt ist. Implizite Konvertierungen gibt es nicht – alle Typumwandlungen müssen mit dem as-Operator explizit geschrieben werden. Dadurch werden typische Fehlerquellen (truncation, sign-confusion, float-to-int-Überraschungen) bereits beim Compilieren erkannt.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:dedingungen?rev=1779467710&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T16:35:10+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Bedingungen (if / else / match)</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:dedingungen?rev=1779467710&amp;do=diff</link>
        <description>Lyx – Bedingungen (if / else / match)

Bedingungen steuern den Kontrollfluss in Lyx. Sie erlauben es, Codeblöcke nur dann auszuführen, wenn eine bestimmte logische Voraussetzung erfüllt ist.

→ Schleifen · Pattern Matching · Sprachsyntax

----------

1. Grundlegende Syntax

Eine</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:do-178c?rev=1779466828&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T16:20:28+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>DO-178C Compliance in Lyx</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:do-178c?rev=1779466828&amp;do=diff</link>
        <description>DO-178C Compliance in Lyx

DO-178C („Software Considerations in Airborne Systems and Equipment Certification“) ist der Industriestandard der Luftfahrtbehörden EASA (Europa) und FAA (USA) für Software in zugelassenen Luftfahrzeugen. Ohne Compliance keine Musterzulassung (Type Certificate). Lyx ist die erste eigenständige Systemsprache, die DO-178C-Konformität als integralen Bestandteil der Sprache — nicht als nachgelagertes Werkzeug — implementiert.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:erste-schritte?rev=1779445083&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T10:18:03+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Erste Schritte</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:erste-schritte?rev=1779445083&amp;do=diff</link>
        <description>Lyx – Erste Schritte

Diese Anleitung führt vom leeren Terminal bis zum ersten lauffähigen Lyx-Programm. Keine Vorkenntnisse in Lyx erforderlich — Grundkenntnisse in einer beliebigen Programmiersprache reichen.

----------

1. Installation

Der Lyx-Compiler</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:exception-handling?rev=1779467645&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T16:34:05+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Fehlerbehandlung</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:exception-handling?rev=1779467645&amp;do=diff</link>
        <description>Lyx – Fehlerbehandlung

Lyx kennt kein try/catch/throw. Das ist eine bewusste Designentscheidung: Exceptions erzeugen nicht-linearen Kontrollfluss, der zur Compile-Zeit schwer nachzuverfolgen ist, WCET-Analysen erschwert und in sicherheitskritischen Systemen verboten ist.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:ffi?rev=1779446943&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T10:49:03+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Foreign Function Interface (FFI)</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:ffi?rev=1779446943&amp;do=diff</link>
        <description>Lyx – Foreign Function Interface (FFI)

Das Foreign Function Interface (FFI) verbindet Lyx mit Code, der in C geschrieben wurde — und umgekehrt. Lyx kann C-Funktionen aufrufen (@extern) und eigene Funktionen für C exportieren (@export). Die Grundlage ist die C ABI der jeweiligen Zielplattform: System V AMD64 auf Linux/macOS, Microsoft x64 auf Windows, AAPCS64 auf ARM64.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:funktionen?rev=1779459103&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T14:11:43+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Funktionen (vertieft)</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:funktionen?rev=1779459103&amp;do=diff</link>
        <description>Funktionen (vertieft)

Funktionen sind der zentrale Baustein jedes Lyx-Programms. Diese Seite geht über die Grunddeklaration hinaus und behandelt Tupel-Rückgaben, anonyme Funktionen, Funktionstypen, Higher-Order Functions und den Pipe-Operator.

→ Einführung:</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:generics-traits?rev=1779443772&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T09:56:12+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Generics &amp; Traits</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:generics-traits?rev=1779443772&amp;do=diff</link>
        <description>Lyx – Generics &amp; Traits

Generics und Traits sind das Typsystem-Fundament für wiederverwendbaren Code in Lyx. Generics erlauben es, Funktionen und Datenstrukturen einmal zu schreiben und für beliebig viele konkrete Typen zu verwenden. Traits definieren die Anforderungen, die ein Typ erfüllen muss, damit er als generischer Parameter zulässig ist.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:lyx-compiler-selbst-kompilieren?rev=1779447519&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T10:58:39+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Compiler selbst kompilieren</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:lyx-compiler-selbst-kompilieren?rev=1779447519&amp;do=diff</link>
        <description>Lyx – Compiler selbst kompilieren

Der Lyx-Compiler lyxc ist in Free Pascal (FPC) implementiert. Das hat einen wesentlichen Vorteil: FPC ist selbst plattformübergreifend verfügbar und erzeugt native Binaries ohne externe Laufzeitabhängigkeiten — genau wie Lyx selbst.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:memory-management?rev=1779449047&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T11:24:07+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Memory Management</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:memory-management?rev=1779449047&amp;do=diff</link>
        <description>Lyx – Memory Management

Lyx hat keinen Garbage Collector. Das ist keine Einschränkung — es ist ein Designziel. GC-Pausen sind nicht-deterministisch: Sie können jederzeit einsetzen, beliebig lange dauern und Echtzeitgarantien zerstören. In eingebetteten Systemen, Flugsteuerungen und Hochlast-Servern ist vorhersagbares Speicherverhalten keine Option, sondern Pflicht.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:ml?rev=1779441008&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T09:10:08+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Machine Learning in Lyx</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:ml?rev=1779441008&amp;do=diff</link>
        <description>Machine Learning in Lyx

Lyx bringt maschinelles Lernen als native Bibliothek mit — kein Python, kein TensorFlow, keine externen Abhängigkeiten. Alle Algorithmen sind direkt in Lyx implementiert und laufen als normaler nativer Code auf x86_64 und ARM64.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:oop?rev=1779449576&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T11:32:56+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Objektorientierte Programmierung</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:oop?rev=1779449576&amp;do=diff</link>
        <description>Lyx – Objektorientierte Programmierung

Lyx unterscheidet bewusst zwischen zwei Arten von benutzerdefinierten Typen: Structs und Klassen. Diese Trennung ist kein Stilmittel — sie macht die Performance-Implikationen im Code sichtbar. Ein Struct liegt auf dem Stack, ein Klassenobjekt auf dem Heap. Ein Struct-Aufruf ist ein direkter Funktionsaufruf, ein virtueller Methodenaufruf geht durch eine V-Table. Beides ist in Lyx explizit und damit für den Entwickler kontrollierbar.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:pattern-matching?rev=1779467686&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T16:34:46+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Pattern Matching</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:pattern-matching?rev=1779467686&amp;do=diff</link>
        <description>Lyx – Pattern Matching

match ist das zentrale Kontrollfluss-Element für Fallunterscheidungen in Lyx. Es ist typsicher, exhaustiv — der Compiler prüft, ob alle möglichen Werte abgedeckt sind — und wird vom Backend oft zu einer Jump-Table optimiert, die schneller ist als eine if/else-Kette.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:pointer-inlining?rev=1779450956&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T11:55:56+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Low-Level: Pointer &amp; Inlining</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:pointer-inlining?rev=1779450956&amp;do=diff</link>
        <description>Lyx – Low-Level: Pointer &amp; Inlining

Systemprogrammierung – Treiber, Kernel-Module, Echtzeit-Regler, Hardware-Abstraktionen – erfordert direkten Zugriff auf Speicheradressen und präzise Kontrolle über den generierten Maschinencode. Lyx bietet dafür ein vollständiges Pointer-Modell nach Pascal-Vorbild sowie mehrere Performance-Pragmas (</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:rekursion?rev=1779451985&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T12:13:05+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Rekursion</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:rekursion?rev=1779451985&amp;do=diff</link>
        <description>Lyx – Rekursion

Rekursion ist ein Kontrollfluss-Muster, bei dem eine Funktion sich selbst aufruft, um ein Problem schrittweise auf einen einfacheren Fall zu reduzieren. Lyx unterstützt Rekursion auf allen Zielplattformen (x86_64, ARM64, RISC-V64) und bietet spezielle Werkzeuge zur Begrenzung und Verifikation des Stack-Verbrauchs – eine Voraussetzung für zertifizierungspflichtige Software nach DO-178C.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:rtos-embedded-concurrency?rev=1779460287&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T14:31:27+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Nebenläufigkeit auf Embedded-Targets &amp; RTOS</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:rtos-embedded-concurrency?rev=1779460287&amp;do=diff</link>
        <description>Nebenläufigkeit auf Embedded-Targets &amp; RTOS

Auf Linux und macOS stellt std.thread POSIX-Threads bereit. Auf Bare-Metal-Targets (ARM Cortex-M, RISC-V ohne Betriebssystem) und RTOS-Umgebungen (FreeRTOS auf ESP32) gelten andere Regeln. Dieses Dokument beschreibt die Muster und Werkzeuge, die Lyx für diese Umgebungen bereitstellt.</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:schleifen?rev=1779453187&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T12:33:07+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Schleifen (Loops)</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:schleifen?rev=1779453187&amp;do=diff</link>
        <description>Lyx – Schleifen (Loops)

Lyx bietet drei Schleifenformen für unterschiedliche Anwendungsfälle: while für bedingungsgesteuerte Schleifen, for für Zählschleifen mit bekanntem Bereich und repeat-until für fußgesteuerte Schleifen. Für sicherheitskritischen Code ergänzt das</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:syntax?rev=1779459202&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T14:13:22+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Syntax-Referenz</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:syntax?rev=1779459202&amp;do=diff</link>
        <description>Lyx – Syntax-Referenz

Diese Seite ist die vollständige Syntax-Referenz für Lyx. Sie beschreibt alle lexikalischen Regeln, Operatoren, Kontrollstrukturen und Deklarationsformen. Für konzeptuelle Erläuterungen und Code-Beispiele zu einzelnen Themen existieren eigene Unterseiten (verlinkt am Ende jedes Abschnitts).</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:threads-nebenlaeufikeit?rev=1779460333&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-22T14:32:13+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Lyx – Threads &amp; Nebenläufigkeit</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:threads-nebenlaeufikeit?rev=1779460333&amp;do=diff</link>
        <description>Lyx – Threads &amp; Nebenläufigkeit

Lyx unterstützt Nebenläufigkeit über POSIX-Threads (pthreads), gekapselt in der Unit std.thread. Sie bietet sechs Primitive: Thread (Ausführungsfaden), Mutex (gegenseitiger Ausschluss), Cond (Bedingungsvariablen),</description>
    </item>
    <item rdf:about="https://doc.seolizer.de/lyx_-_programmiersprache:units?rev=1779523886&amp;do=diff">
        <dc:format>text/html</dc:format>
        <dc:date>2026-05-23T08:11:26+00:00</dc:date>
        <dc:creator>Anonymous (anonymous@undisclosed.example.com)</dc:creator>
        <title>Standard-Units Übersicht</title>
        <link>https://doc.seolizer.de/lyx_-_programmiersprache:units?rev=1779523886&amp;do=diff</link>
        <description>Standard-Units Übersicht

Stand: 2026-05-23 · Verzeichnis: std/

Die Standardbibliothek von Lyx umfasst 170 Units in 22 Kategorien. Sie folgt dem Prinzip Zero-External-Dependencies: Jede Unit ist entweder vollständig in Lyx implementiert oder wrappet direkt POSIX-Syscalls – ohne weitere Laufzeitbibliotheken als Pflichtabhängigkeit. Ausnahmen (OpenSSL, libssh2, mpg123, ALSA, Qt5) sind explizit dokumentiert und optional.</description>
    </item>
</rdf:RDF>
