====== Welche Unit brauche ich? ======

Task-orientierter Wegweiser durch die Standardbibliothek. Ausgangspunkt ist immer die konkrete Aufgabe — nicht der Namespace. Jede Zeile verweist auf die präziseste Unit; Links direkt zur Detailseite.

→ [[lyx_-_programmiersprache:units|Alle Units alphabetisch]] · [[lyx_-_programmiersprache:erste-schritte|Erste Schritte]]

----

===== Netzwerk & Kommunikation =====

^ Ich will … ^ Unit ^
| TCP-Verbindung aufbauen (Client) | ''[[lyx_-_programmiersprache:units:net:socket|std.net.socket]]'' |
| TCP-Server bauen (wenige Verbindungen) | ''[[lyx_-_programmiersprache:units:net:socket|std.net.socket]]'' |
| TCP-Server bauen (1 000+ gleichzeitige Verbindungen) | ''[[lyx_-_programmiersprache:units:net:epoll|std.net.epoll]]'' + ''[[lyx_-_programmiersprache:units:net:socket|std.net.socket]]'' |
| HTTP-Request (GET/POST) absetzen | ''[[lyx_-_programmiersprache:units:net:http|std.net.http]]'' |
| HTTPS-Request absetzen | ''[[lyx_-_programmiersprache:units:net:https|std.net.https]]'' |
| TLS-Verbindung manuell aufbauen | ''[[lyx_-_programmiersprache:units:net:tls|std.net.tls]]'' |
| Domain-Name auflösen (DNS) | ''[[lyx_-_programmiersprache:units:net:dns|std.net.dns]]'' |
| E-Mail versenden (SMTP) | ''[[lyx_-_programmiersprache:units:net:smtp|std.net.smtp]]'' |
| E-Mails abrufen (IMAP) | ''[[lyx_-_programmiersprache:units:net:imap|std.net.imap]]'' |
| SSH-Befehl remote ausführen | ''[[lyx_-_programmiersprache:units:net:ssh|std.net.ssh]]'' |
| IoT-Gerät via MQTT anbinden | ''[[lyx_-_programmiersprache:units:net:mqtt|std.net.mqtt]]'' |
| Zeit per NTP synchronisieren | ''[[lyx_-_programmiersprache:units:net:ntp|std.net.ntp]]'' |
| WHOIS-Abfrage für Domain oder IP | ''[[lyx_-_programmiersprache:units:net:whois|std.net.whois]]'' |
| LDAP / Active Directory abfragen | ''[[lyx_-_programmiersprache:units:net:ldap|std.net.ldap]]'' |
| Netzwerk-Gerät per SNMP auslesen | ''[[lyx_-_programmiersprache:units:net:snmp|std.net.snmp]]'' |
| VoIP / SIP-Signaling | ''[[lyx_-_programmiersprache:units:net:sip|std.net.sip]]'' |
| UDP-Socket direkt verwenden | ''[[lyx_-_programmiersprache:units:net:socket|std.net.socket]]'' |
| Ereignis-fd für Thread-Wakeup | ''[[lyx_-_programmiersprache:units:net:epoll|std.net.epoll]]'' (''EventFdCreate'') |
| Android-Netzwerk-Syscalls | ''[[lyx_-_programmiersprache:units:net:internal:syscalls_android|std.net.internal.syscalls_android]]'' |

----

===== Datenbanken =====

^ Ich will … ^ Unit ^
| MySQL oder MariaDB abfragen | ''[[lyx_-_programmiersprache:units:db:mysql|std.db.mysql]]'' |
| PostgreSQL abfragen (ohne libpq) | ''[[lyx_-_programmiersprache:units:db:postgres|std.db.postgres]]'' |
| Embedded-DB / Single-File / Mobile | ''[[lyx_-_programmiersprache:units:db:sqlite|std.db.sqlite]]'' |
| In-Memory-Datenbank (SQLite) | ''[[lyx_-_programmiersprache:units:db:sqlite|std.db.sqlite]]'' (''SQLiteOpen(":memory:")'') |
| Sessions oder Caching speichern | ''[[lyx_-_programmiersprache:units:db:redis|std.db.redis]]'' |
| Pub/Sub zwischen Prozessen | ''[[lyx_-_programmiersprache:units:db:redis|std.db.redis]]'' |
| Redis ohne std.string-Abhängigkeit | ''[[lyx_-_programmiersprache:units:db:redis_simple|std.db.redis_simple]]'' |
| JSON-Dokumente speichern | ''[[lyx_-_programmiersprache:units:net:mongo|std.net.mongo]]'' |
| PostgreSQL Connection Pooling | ''[[lyx_-_programmiersprache:units:db:postgres|std.db.postgres]]'' (''PGPoolCreate'') |
| Bulk-Import (tausende Rows schnell) | ''[[lyx_-_programmiersprache:units:db:postgres|std.db.postgres]]'' (COPY) · ''[[lyx_-_programmiersprache:units:db:sqlite|std.db.sqlite]]'' (Transaktion) |

----

===== PDF erstellen =====

^ Ich will … ^ Unit ^
| Einfaches PDF mit Text und Linien | ''[[lyx_-_programmiersprache:units:pdf:builder|std.pdf.builder]]'' + ''[[lyx_-_programmiersprache:units:pdf:graphics|std.pdf.graphics]]'' |
| Schriftart auswählen (Helvetica, Times …) | ''[[lyx_-_programmiersprache:units:pdf:fonts|std.pdf.fonts]]'' |
| Umlaute / Unicode-Text einbetten | ''[[lyx_-_programmiersprache:units:pdf:ttfont|std.pdf.ttfont]]'' (TrueType + Subsetting) |
| Rasterbilder einfügen (JPEG/PNG) | ''[[lyx_-_programmiersprache:units:pdf:image|std.pdf.image]]'' |
| Farbverlauf (linear oder radial) | ''[[lyx_-_programmiersprache:units:pdf:shading|std.pdf.shading]]'' |
| PANTONE / Sonderfarbe verwenden | ''[[lyx_-_programmiersprache:units:pdf:spot|std.pdf.spot]]'' |
| Grafik-Block mehrfach wiederverwenden | ''[[lyx_-_programmiersprache:units:pdf:xobject|std.pdf.xobject]]'' |
| Interaktives Formular erstellen | ''[[lyx_-_programmiersprache:units:pdf:forms|std.pdf.forms]]'' |
| Formular-Felder einfrieren (flatten) | ''[[lyx_-_programmiersprache:units:pdf:forms|std.pdf.forms]]'' (''PdfFlattenForms'') |
| Lesezeichen (Outline/Bookmarks) | ''[[lyx_-_programmiersprache:units:pdf:outline|std.pdf.outline]]'' |
| Hyperlinks und Annotationen | ''[[lyx_-_programmiersprache:units:pdf:annot|std.pdf.annot]]'' |
| Dokument-Metadaten (Titel, Autor) | ''[[lyx_-_programmiersprache:units:pdf:meta|std.pdf.meta]]'' |
| XMP-Metadaten einbetten | ''[[lyx_-_programmiersprache:units:pdf:xmp|std.pdf.xmp]]'' |
| PDF/A (Langzeitarchivierung) | ''[[lyx_-_programmiersprache:units:pdf:pdfa|std.pdf.pdfa]]'' + ''[[lyx_-_programmiersprache:units:pdf:xmp|std.pdf.xmp]]'' |
| ZUGFeRD / Factur-X Rechnung | ''[[lyx_-_programmiersprache:units:pdf:pdfa|std.pdf.pdfa]]'' (A-3b) + ''[[lyx_-_programmiersprache:units:pdf:attach|std.pdf.attach]]'' |
| Layer (ein-/ausblendbare Ebenen) | ''[[lyx_-_programmiersprache:units:pdf:layer|std.pdf.layer]]'' |
| Seitenübergänge (Präsentation) | ''[[lyx_-_programmiersprache:units:pdf:transition|std.pdf.transition]]'' |
| Vorhandenes PDF öffnen / analysieren | ''[[lyx_-_programmiersprache:units:pdf:reader|std.pdf.reader]]'' |

----

===== Dateisystem & I/O =====

^ Ich will … ^ Unit ^
| Datei öffnen, lesen, schreiben, schließen | ''[[lyx_-_programmiersprache:units:fs|std.fs]]'' |
| Datei-Metadaten lesen (fstat, Größe) | ''[[lyx_-_programmiersprache:units:fs_ext|std.fs_ext]]'' |
| Scatter/Gather-I/O (readv/writev) | ''[[lyx_-_programmiersprache:units:fs_ext|std.fs_ext]]'' |
| Positional-I/O (pread/pwrite) | ''[[lyx_-_programmiersprache:units:fs_ext|std.fs_ext]]'' |
| Datei direkt zu Socket senden (sendfile) | ''[[lyx_-_programmiersprache:units:fs_ext|std.fs_ext]]'' |
| Verzeichnisinhalt auflisten (DirList) | ''[[lyx_-_programmiersprache:units:fs|std.fs]]'' (''DirList'' / ''DirEntryName'' / ''DirEntryTypeAt'') |
| Verzeichnis rekursiv traversieren | ''[[lyx_-_programmiersprache:units:fs|std.fs]]'' (''DirWalk'') |
| Dateien nach Wildcard suchen (*.log) | ''[[lyx_-_programmiersprache:units:fs|std.fs]]'' (''FileGlob'') |
| Einmalige Temp-Datei anlegen | ''[[lyx_-_programmiersprache:units:fs|std.fs]]'' (''TmpFile()'') |
| Erweitertes Attribut (xattr) lesen/schreiben | ''[[lyx_-_programmiersprache:units:xattr|std.xattr]]'' |
| Freien Speicher eines Dateisystems abfragen | ''[[lyx_-_programmiersprache:units:xattr|std.xattr]]'' (''StatFsFreeBytes'') |
| Speicherplatz für Datei vorab reservieren | ''[[lyx_-_programmiersprache:units:xattr|std.xattr]]'' (''FileAllocate'') |
| Asynchrones I/O (viele gleichzeitige Ops) | ''[[lyx_-_programmiersprache:units:io_uring|std.io_uring]]'' |
| Dateisystem-Änderungen überwachen | ''[[lyx_-_programmiersprache:units:inotify|std.inotify]]'' |
| Pipe zwischen Prozessen | ''[[lyx_-_programmiersprache:units:pipe|std.pipe]]'' |
| Dateideskriptor duplizieren (dup/dup2) | ''[[lyx_-_programmiersprache:units:pipe|std.pipe]]'' |
| Anonyme In-Memory-Datei (memfd) | ''[[lyx_-_programmiersprache:units:mmap_ext|std.mmap_ext]]'' |
| Shared Memory (mmap + ftruncate) | ''[[lyx_-_programmiersprache:units:mmap_ext|std.mmap_ext]]'' |
| Mapping wachsen lassen (mremap) | ''[[lyx_-_programmiersprache:units:mmap_ext|std.mmap_ext]]'' |
| Seiten im RAM fixieren (mlock) | ''[[lyx_-_programmiersprache:units:mmap_ext|std.mmap_ext]]'' |
| IPC Message Queues (POSIX mq) | ''[[lyx_-_programmiersprache:units:mqueue|std.mqueue]]'' |

----

===== Archiv & Kompression =====

^ Ich will … ^ Unit ^
| ZIP-Archiv lesen (stored + deflated) | ''[[lyx_-_programmiersprache:units:zip|std.zip]]'' (''ZipOpen'', ''ZipRead'') |
| ZIP-Archiv erstellen | ''[[lyx_-_programmiersprache:units:zip|std.zip]]'' (''ZipWriterNew'', ''ZipWriterAdd'', ''ZipWriterSave'') |
| Einzelne Datei in ZIP suchen | ''[[lyx_-_programmiersprache:units:zip|std.zip]]'' (''ZipFind'') |
| TAR-Archiv lesen (POSIX ustar) | ''[[lyx_-_programmiersprache:units:tar|std.tar]]'' (''TarOpen'', ''TarRead'') |
| TAR-Archiv erstellen | ''[[lyx_-_programmiersprache:units:tar|std.tar]]'' (''TarWriterNew'', ''TarWriterAdd'', ''TarWriterSave'') |
| .tar.gz erzeugen | ''[[lyx_-_programmiersprache:units:tar|std.tar]]'' + ''[[lyx_-_programmiersprache:units:zlib|std.zlib]]'' (TarWriterSave → GzipCompress) |
| RAR5-Archiv lesen (nur stored) | ''[[lyx_-_programmiersprache:units:rar|std.rar]]'' (''RarOpen'', ''RarRead'') |
| RAR-Archiv erstellen | nicht möglich — RARLAB-Lizenz nötig; stattdessen ''[[lyx_-_programmiersprache:units:zip|std.zip]]'' verwenden |
| ISO 9660-Image lesen (CD/DVD-Inhalt extrahieren) | ''[[lyx_-_programmiersprache:units:iso|std.iso]]'' (''IsoOpen'', ''IsoRead'') |
| ISO 9660-Image erstellen | ''[[lyx_-_programmiersprache:units:iso|std.iso]]'' (''IsoWriterNew'', ''IsoWriterAdd'', ''IsoWriterSave'') |
| ISO 9660 vollständiger Guide | → [[lyx_-_programmiersprache:guides:iso|ISO Guide]] |
| Rohe DEFLATE-Kompression / -Dekompression | ''[[lyx_-_programmiersprache:units:zlib|std.zlib]]'' |
| Brotli-Stream dekomprimieren (HTTP ''Content-Encoding: br'') | ''[[lyx_-_programmiersprache:units:brotli|std.brotli]]'' (''BrotliDecompress'') |
| Brotli-Stream komprimieren (Store-Modus, gültig aber unkomprimiert) | ''[[lyx_-_programmiersprache:units:brotli|std.brotli]]'' (''BrotliCompress'') |
| Zstd-Stream (.zst, Kafka, Docker-Layer) dekomprimieren | ''[[lyx_-_programmiersprache:units:zstd|std.zstd]]'' (''ZstdDecompress'') |
| Zstd-Stream komprimieren (Store-Modus, gültig aber unkomprimiert) | ''[[lyx_-_programmiersprache:units:zstd|std.zstd]]'' (''ZstdCompress'') |

----

===== Strings & Datenformate =====

^ Ich will … ^ Unit ^
| Strings suchen, ersetzen, trimmen | ''[[lyx_-_programmiersprache:units:string|std.string]]'' |
| String mit Platzhaltern formatieren (%s/%d/%x) | ''[[lyx_-_programmiersprache:units:string|std.string]]'' (''StrFormat'') |
| Regex-Matching und -Suche | ''[[lyx_-_programmiersprache:units:regex|std.regex]]'' |
| JSON lesen oder schreiben | ''[[lyx_-_programmiersprache:units:json|std.json]]'' |
| XML parsen oder erzeugen | ''[[lyx_-_programmiersprache:units:xml|std.xml]]'' |
| YAML-Konfiguration laden | ''[[lyx_-_programmiersprache:units:yaml|std.yaml]]'' |
| INI-Konfigurationsdatei einlesen | ''[[lyx_-_programmiersprache:units:ini|std.ini]]'' |
| URL parsen (Schema, Host, Query) | ''[[lyx_-_programmiersprache:units:url|std.url]]'' |
| URL aus Teilen zusammenbauen | ''[[lyx_-_programmiersprache:units:url|std.url]]'' (''URLBuild'') |
| Query-Parameter lesen oder setzen | ''[[lyx_-_programmiersprache:units:url|std.url]]'' (''URLQueryGet'' / ''URLQuerySet'') |
| Relativen URL gegen Basis auflösen | ''[[lyx_-_programmiersprache:units:url|std.url]]'' (''URLResolve'') |
| Percent-Encoding / -Decoding (RFC 3986) | ''[[lyx_-_programmiersprache:units:url|std.url]]'' (''URLPercentEncode'' / ''URLPercentDecode'') |
| Base64 kodieren/dekodieren | ''[[lyx_-_programmiersprache:units:base64|std.base64]]'' |
| HTML escapen / Tags entfernen | ''[[lyx_-_programmiersprache:units:html|std.html]]'' |
| Binär serialisieren (VarInt, Pack) | ''[[lyx_-_programmiersprache:units:pack|std.pack]]'' |
| Struct-Feld auf exaktes Byte-Offset legen (Protokoll-Header) | ''[[lyx_-_programmiersprache:sprache:attributes-pragmas|@at(N)]]'' |
| Mehrbyte-Feld als Big-Endian / Network Byte Order markieren | ''[[lyx_-_programmiersprache:sprache:attributes-pragmas|@big_endian]]'' |
| Daten komprimieren (zlib/DEFLATE) | ''[[lyx_-_programmiersprache:units:zlib|std.zlib]]'' |
| Hex/Binär/Oktal-Konvertierung | ''[[lyx_-_programmiersprache:units:conv|std.conv]]'' |

----

===== Kryptografie & Sicherheit =====

→ [[lyx_-_programmiersprache:guides:kryptographie|Kryptographie-Guide: Vergleich aller Units, Empfehlungen, Entscheidungsguide]]

^ Ich will … ^ Unit ^
| Daten mit AES-128/256 verschlüsseln | ''[[lyx_-_programmiersprache:units:crypto:aes|std.crypto.aes]]'' |
| MD5-Hash (Checksum / Protokoll) | ''[[lyx_-_programmiersprache:units:crypto:md5|std.crypto.md5]]'' |
| SHA-1-Hash (Git-Objekte, MySQL-Auth) | ''[[lyx_-_programmiersprache:units:crypto:sha1|std.crypto.sha1]]'' |
| SHA-256-Hash (FIPS 180-4, one-shot) | ''[[lyx_-_programmiersprache:units:crypto:sha256|std.crypto.sha256]]'' |
| HMAC-SHA256 (Nachrichten-Authentifizierung) | ''[[lyx_-_programmiersprache:units:crypto:hmac|std.crypto.hmac]]'' |
| ECDSA-Signatur erzeugen / prüfen (secp256k1) | ''[[lyx_-_programmiersprache:units:crypto:ecc|std.crypto.ecc]]'' |
| Kryptografisch sichere Zufallsbytes | ''[[lyx_-_programmiersprache:units:crypto:rand|std.crypto.rand]]'' (''RandBytesExact'') |
| Sicheren Zufalls-int64 erzeugen | ''[[lyx_-_programmiersprache:units:crypto:rand|std.crypto.rand]]'' (''RandInt64'' — 0 bei Fehler; für sicherheitskritischen Code ''RandBytesExact'' bevorzugen) |
| Passwort sicher hashen (bcrypt/Argon2) | ''[[lyx_-_programmiersprache:units:hash|std.hash]]'' |
| TLS/HTTPS-Verbindung aufbauen | ''[[lyx_-_programmiersprache:units:net:tls|std.net.tls]]'' |
| Binary-Integrität zur Laufzeit prüfen | ''[[lyx_-_programmiersprache:units:meta_safe|std.meta_safe]]'' |
| UUID zufällig oder zeitbasiert erzeugen | ''[[lyx_-_programmiersprache:units:uuid|std.uuid]]'' |
| Symmetrisch authentifiziert verschlüsseln (Latin-Square, 128-Bit Quantensicherheit) | ''[[lyx_-_programmiersprache:units:crypto:pqc:dadq|std.crypto.pqc.dadq]]'' → ''dadqFOEnc'' / ''dadqFODec'' (FO-Modus empfohlen) |
| DADQ-Schlüssel für PKE kapseln (Hybrid) | ''std.crypto.pqc.dadq'' + ''[[lyx_-_programmiersprache:units:crypto:pqc:mlkem|std.crypto.pqc.mlkem]]'': ML-KEM kapselt den 32-Byte master_seed |
| Post-Quantum-Schlüsselaustausch (ersetzt ECDH) | ''[[lyx_-_programmiersprache:units:crypto:pqc:pqc|std.crypto.pqc.pqc]]'' → ''PQCKeyGen(PQC_ALG_MLKEM_768)'' |
| Post-Quantum-Schlüsselaustausch + klassisch (Signal/Apple-Schema) | ''[[lyx_-_programmiersprache:units:crypto:pqc:pqc|std.crypto.pqc.pqc]]'' → ''PQCKeyGen(PQC_ALG_HYBRID_768)'' |
| Post-Quantum-Signatur (ersetzt ECDSA) | ''[[lyx_-_programmiersprache:units:crypto:pqc:pqc|std.crypto.pqc.pqc]]'' → ''PQCKeyGen(PQC_ALG_MLDSA_65)'' |
| Post-Quantum-Signatur (nur SHA-256-Annahmen, kleiner PK) | ''[[lyx_-_programmiersprache:units:crypto:pqc:pqc|std.crypto.pqc.pqc]]'' → ''PQCKeyGen(PQC_ALG_SLHDSA_128S)'' |

----

===== Prozesse, Threads & IPC =====

^ Ich will … ^ Unit ^
| Neuen Prozess starten (fork/exec) | ''[[lyx_-_programmiersprache:units:process|std.process]]'' |
| Shell-Befehl ausführen + Ausgabe lesen | ''[[lyx_-_programmiersprache:units:process|std.process]]'' (''Shell'') |
| POSIX-Threads anlegen | ''[[lyx_-_programmiersprache:units:thread|std.thread]]'' |
| Mutex / Bedingungsvariablen | ''[[lyx_-_programmiersprache:units:thread|std.thread]]'' |
| Signale abfangen (SIGTERM, SIGUSR1 …) | ''[[lyx_-_programmiersprache:units:signals|std.signals]]'' |
| Signal als fd lesen (signalfd) | ''[[lyx_-_programmiersprache:units:signals|std.signals]]'' |
| CPU-Affinität setzen (CPU-Pinning) | ''[[lyx_-_programmiersprache:units:sched|std.sched]]'' |
| Nice-Wert / Prozess-Priorität ändern | ''[[lyx_-_programmiersprache:units:sched|std.sched]]'' |
| UID/GID lesen, Root prüfen | ''[[lyx_-_programmiersprache:units:process_ext|std.process_ext]]'' |
| Session / Prozessgruppe wechseln | ''[[lyx_-_programmiersprache:units:process_ext|std.process_ext]]'' |
| Systeminformationen (/proc) auslesen | ''[[lyx_-_programmiersprache:units:systeminfo|std.systeminfo]]'' |
| IPC über POSIX Message Queues | ''[[lyx_-_programmiersprache:units:mqueue|std.mqueue]]'' |
| IPC über Pipes | ''[[lyx_-_programmiersprache:units:pipe|std.pipe]]'' |
| SysV Shared Memory (shmget/shmat) | ''[[lyx_-_programmiersprache:units:ipc_sysv|std.ipc_sysv]]'' (''ShmCreate'' / ''ShmAttach'') |
| SysV Semaphore (P/V-Operationen) | ''[[lyx_-_programmiersprache:units:ipc_sysv|std.ipc_sysv]]'' (''SemCreate'' / ''SemWait'' / ''SemPost'') |
| SysV Message Queue | ''[[lyx_-_programmiersprache:units:ipc_sysv|std.ipc_sysv]]'' (''MsgQueueCreate'' / ''MsgSend'' / ''MsgRecv'') |
| Signal race-frei an Prozess senden (pidfd) | ''[[lyx_-_programmiersprache:units:ns|std.ns]]'' (''PidFdOpen'' / ''PidFdSendSignal'') |

----

===== System & Kernel =====

^ Ich will … ^ Unit ^
| Asynchrones I/O (io_uring, Kernel 5.1+) | ''[[lyx_-_programmiersprache:units:io_uring|std.io_uring]]'' |
| SysV IPC (Shared Memory, Semaphore, Queues) | ''[[lyx_-_programmiersprache:units:ipc_sysv|std.ipc_sysv]]'' |
| eBPF-Programm laden und Maps verwalten | ''[[lyx_-_programmiersprache:units:bpf|std.bpf]]'' (braucht CAP_BPF oder CAP_SYS_ADMIN) |
| Prozess per ptrace debuggen / tracen | ''[[lyx_-_programmiersprache:units:debug|std.debug]]'' (''PtraceAttach'' / ''PtraceGetRegs'') |
| Hardware-Performance-Counter auslesen | ''[[lyx_-_programmiersprache:units:debug|std.debug]]'' (''PerfEventOpen'' / ''PerfCount'') |
| Linux-Namespaces wechseln / trennen | ''[[lyx_-_programmiersprache:units:ns|std.ns]]'' (''NamespaceUnshare'' / ''NamespaceJoin'') |
| Process-Capabilities lesen / abgeben | ''[[lyx_-_programmiersprache:units:security_ext|std.security_ext]]'' (''CapGet'' / ''CapDrop'') |
| PR_SET_NO_NEW_PRIVS setzen (irreversibel) | ''[[lyx_-_programmiersprache:units:security_ext|std.security_ext]]'' (''ProcessSetNoNewPrivs'') |
| Prozessname setzen (prctl PR_SET_NAME) | ''[[lyx_-_programmiersprache:units:security_ext|std.security_ext]]'' (''ProcessSetName'') |
| Dateisystem mounten / unmounten | ''[[lyx_-_programmiersprache:units:sysadmin|std.sysadmin]]'' (''Mount'' / ''Umount'') |
| Root-Verzeichnis wechseln (chroot) | ''[[lyx_-_programmiersprache:units:sysadmin|std.sysadmin]]'' (''Chroot'') |
| Hostnamen setzen | ''[[lyx_-_programmiersprache:units:sysadmin|std.sysadmin]]'' (''SetHostname'') |
| System-Reboot / Poweroff auslösen | ''[[lyx_-_programmiersprache:units:sysadmin|std.sysadmin]]'' (''Reboot'') |

----

===== Ausgabe & Benutzeroberflächen =====

^ Ich will … ^ Unit ^
| Text und Zahlen ausgeben | ''[[lyx_-_programmiersprache:units:io|std.io]]'' |
| Terminal mit ANSI-Farben und Cursor | ''[[lyx_-_programmiersprache:units:crt|std.crt]]'' |
| Einzelne Zeichen non-blocking lesen | ''[[lyx_-_programmiersprache:units:crt_raw|std.crt_raw]]'' |
| Vollständige TUI (Fenster, Dialoge, Menüs) | ''[[lyx_-_programmiersprache:units:lyxvision:app|LyxVision]]'' |
| LyxVision vollständiger Guide | → [[lyx_-_programmiersprache:guides:lyxvision|LyxVision-Guide]] |
| Desktop-GUI-Fenster mit Qt5 | ''[[lyx_-_programmiersprache:units:qt5_app|std.qt5_app]]'' |
| OpenGL in Qt5-Fenster | ''[[lyx_-_programmiersprache:units:qt5_gl|std.qt5_gl]]'' |
| Strukturiertes Logging (5 Level) | ''[[lyx_-_programmiersprache:units:log|std.log]]'' |
| JSON-Logzeile mit Key-Value (log_info_kv) | ''[[lyx_-_programmiersprache:units:log|std.log]]'' (''log_info_kv'') |
| SVG-Grafik programmatisch erzeugen | ''[[lyx_-_programmiersprache:units:svg|std.svg]]'' |
| SVG vollständiger Guide | → [[lyx_-_programmiersprache:guides:svg|SVG-Guide]] |

----

===== Mathematik & Algorithmen =====

^ Ich will … ^ Unit ^
| sin, cos, sqrt, pow, floor, round … | ''[[lyx_-_programmiersprache:units:math|std.math]]'' |
| Arcustangens (atan / atan2) | ''[[lyx_-_programmiersprache:units:math|std.math]]'' (''AtanF64'' / ''Atan2F64'') |
| Arcussinus / Arcuskosinus | ''[[lyx_-_programmiersprache:units:math|std.math]]'' (''AsinF64'' / ''AcosF64'') |
| Binärer Logarithmus (log₂) | ''[[lyx_-_programmiersprache:units:math|std.math]]'' (''Log2F64'') |
| Geometrische 2D-Vektoren (Vec2) | ''[[lyx_-_programmiersprache:units:vector|std.vector]]'' |
| Array sortieren | ''[[lyx_-_programmiersprache:units:sort|std.sort]]'' |
| Statistik (Mittelwert, Median, StdDev) | ''[[lyx_-_programmiersprache:units:stats|std.stats]]'' |
| GPS-Distanz / Haversine | ''[[lyx_-_programmiersprache:units:geo|std.geo]]'' |
| Farben (RGBA, HSL, Blend) | ''[[lyx_-_programmiersprache:units:color|std.color]]'' |
| Lineare Regression, KNN, K-Means | ''[[lyx_-_programmiersprache:units:ml|std.ml]]'' |
| Wort-Embeddings (FastText) | ''[[lyx_-_programmiersprache:units:fasttext|std.fasttext]]'' |

----

===== CPU & SIMD =====

^ Ich will … ^ Unit ^
| CPU-Fähigkeiten erkennen (SSE2, SSE4.1, AVX2) | ''[[lyx_-_programmiersprache:units:cpu:features|std.cpu.features]]'' (''CpuHasSSE2'', ''CpuHasAVX2'') |
| Besten SIMD-Pfad zur Laufzeit wählen | ''[[lyx_-_programmiersprache:units:cpu:dispatch|std.cpu.dispatch]]'' (''CpuDispatchLevel'') |
| 16-Byte-ausgerichtetes f32-Array anlegen | ''[[lyx_-_programmiersprache:units:cpu:dispatch|std.cpu.dispatch]]'' (''SimdAlloc'') |
| Elementweise f32-Addition auf Arrays | ''[[lyx_-_programmiersprache:units:cpu:dispatch|std.cpu.dispatch]]'' (''SimdAdd'') |
| Elementweise f32-Multiplikation auf Arrays | ''[[lyx_-_programmiersprache:units:cpu:dispatch|std.cpu.dispatch]]'' (''SimdMul'') |
| Einzelnes Element eines SIMD-Arrays lesen | ''[[lyx_-_programmiersprache:units:cpu:dispatch|std.cpu.dispatch]]'' (''SimdGet'') |
| SIMD-Array-Länge abfragen | ''[[lyx_-_programmiersprache:units:cpu:dispatch|std.cpu.dispatch]]'' (''SimdLen'') |
| GPU-Berechnungen (CUDA/Vulkan/OpenCL) | ''std.gpu.*'' — **noch nicht implementiert** (geplant WP-GPU-07–09) |

----

===== Validierung =====

^ Ich will … ^ Unit ^
| IBAN validieren | ''[[lyx_-_programmiersprache:units:validate:iban|std.validate.iban]]'' |
| Kreditkartennummer prüfen (Luhn) | ''[[lyx_-_programmiersprache:units:validate:luhn|std.validate.luhn]]'' |
| EAN-8/13-Barcode prüfen | ''[[lyx_-_programmiersprache:units:validate:ean|std.validate.ean]]'' |
| ISBN-10/13 prüfen | ''[[lyx_-_programmiersprache:units:validate:isbn|std.validate.isbn]]'' |
| EU-Umsatzsteuer-ID prüfen | ''[[lyx_-_programmiersprache:units:validate:vat|std.validate.vat]]'' |
| VIN / Fahrzeugidentifikationsnummer | ''[[lyx_-_programmiersprache:units:validate:vin|std.validate.vin]]'' |
| ISIN (Wertpapierkennung) | ''[[lyx_-_programmiersprache:units:validate:isin|std.validate.isin]]'' |
| Deutsche Steuer-ID / RVNR | ''[[lyx_-_programmiersprache:units:validate:de_personal|std.validate.de_personal]]'' |
| Alle Validierungen → Übersicht | ''[[lyx_-_programmiersprache:units:validate|std.validate]]'' |
| Validierung vollständiger Guide | → [[lyx_-_programmiersprache:guides:validate|Validierungs-Guide]] |

----

===== Audio & Hardware =====

^ Ich will … ^ Unit ^
| WAV-Datei laden oder schreiben | ''[[lyx_-_programmiersprache:units:audio|std.audio]]'' |
| WAV-Datei abspielen (einfach) | ''[[lyx_-_programmiersprache:units:audio:playback|std.audio.playback]]'' |
| PCM direkt per ALSA ausgeben | ''[[lyx_-_programmiersprache:units:audio:alsa|std.audio.alsa]]'' |
| MP3 dekodieren | ''[[lyx_-_programmiersprache:units:audio:mpg123|std.audio.mpg123]]'' |
| Bluetooth vollständiger Guide | → [[lyx_-_programmiersprache:guides:bluetooth|Bluetooth-Guide]] |
| Bluetooth BLE-Gerät als GATT-Client | ''[[lyx_-_programmiersprache:units:hardware:bluetooth_gattc|std.hardware.bluetooth_gattc]]'' |
| Eigenen BLE-Service anbieten (GATT-Server) | ''[[lyx_-_programmiersprache:units:hardware:bluetooth_gatts|std.hardware.bluetooth_gatts]]'' (''GattServerRegister'') |
| Classic Bluetooth (RFCOMM, seriell) | ''[[lyx_-_programmiersprache:units:hardware:bluetooth_rfcomm|std.hardware.bluetooth_rfcomm]]'' (''RFCommConnect'' / ''RFCommSend'') |
| Bluetooth-Gerät discovern, pairen, verbinden (BlueZ) | ''[[lyx_-_programmiersprache:units:hardware:bluetooth_dbus|std.hardware.bluetooth_dbus]]'' (''BlueZStartDiscovery'' / ''BlueZConnectDevice'') |
| BLE-Geräte in der Umgebung scannen | ''[[lyx_-_programmiersprache:units:hardware:bluetooth_ext|std.hardware.bluetooth_ext]]'' (''BleScannerStart'' / ''BleScannerReadNext'') |
| BLE-Advertising (als Peripheral senden) | ''[[lyx_-_programmiersprache:units:hardware:bluetooth_ext|std.hardware.bluetooth_ext]]'' (''BleAdvertisementRegister'') |
| GATT-Characteristics typsicher verwenden | ''[[lyx_-_programmiersprache:units:hardware:bluetooth_ai|std.hardware.bluetooth_ai]]'' (''MakeReadableChar'' / ''MakeNotifiableChar'') |
| USB vollständiger Guide | → [[lyx_-_programmiersprache:guides:usb|USB-Guide]] |
| USB-Gerät nach VID/PID finden und öffnen | ''[[lyx_-_programmiersprache:units:hardware:usb|std.hardware.usb_discovery]]'' (''UsbFindDevice'') |
| USB Descriptor-Baum lesen (Config/Interface/Endpoint) | ''[[lyx_-_programmiersprache:units:hardware:usb|std.hardware.usb_parse]]'' (''UsbAllocDevice'' / ''UsbParseConfiguration'') |
| USB Device Descriptor lesen (VID/PID, Class) | ''[[lyx_-_programmiersprache:units:hardware:usb|std.hardware.usb_control]]'' (''UsbGetDeviceDescriptor'') |
| Interface für exklusiven Zugriff beanspruchen | ''[[lyx_-_programmiersprache:units:hardware:usb|std.hardware.usb_control]]'' (''UsbClaimInterface'') |
| Bulk-Daten an USB-Gerät senden | ''[[lyx_-_programmiersprache:units:hardware:usb|std.hardware.usb_bulk]]'' (''UsbBulkWrite'') |
| Bulk-Daten von USB-Gerät empfangen | ''[[lyx_-_programmiersprache:units:hardware:usb|std.hardware.usb_bulk]]'' (''UsbBulkRead'') |
| Interrupt-Transfer asynchron lesen (HID, Gamepad) | ''[[lyx_-_programmiersprache:units:hardware:usb|std.hardware.usb_interrupt]]'' (''UsbSubmitInterruptRead'' / ''UsbWaitForUrb'') |
| Kontinuierlichen HID-Stream mit URB-Pool lesen | ''[[lyx_-_programmiersprache:units:hardware:usb|std.hardware.usb_urb_pool]]'' (''UsbUrbPoolInit'' / ''UsbUrbPoolPoll'') |
| Audio/Video per Isochronous Transfer streamen | ''[[lyx_-_programmiersprache:units:hardware:usb|std.hardware.usb_iso]]'' (''UsbSubmitIsoRead'' / ''UsbReapIsoUrb'') |
| Endpoint-Richtung typsicher absichern | ''[[lyx_-_programmiersprache:units:hardware:usb|std.hardware.usb_endpoint_types]]'' (''UsbMakeBulkOut'' / ''UsbMakeBulkIn'') |
| Endpoint-Adresse einmalig binden und per Key nutzen | ''[[lyx_-_programmiersprache:units:hardware:usb|std.hardware.usb_endpoint_bind]]'' (''UsbDefOutEndpoint'' / ''UsbEpWrite'') |
| Interface-Claim idempotent verwalten | ''[[lyx_-_programmiersprache:units:hardware:usb|std.hardware.usb_ifc_mgr]]'' (''UsbIfcAcquire'' / ''UsbIfcRelease'') |
| Übersicht aller USB-Units | ''[[lyx_-_programmiersprache:units:hardware:usb|std.hardware.usb]]'' |
| GPIO vollständiger Guide | → [[lyx_-_programmiersprache:guides:gpio|GPIO-Guide]] |
| GPIO-Pin als Ausgang schalten (LED, Relais) | ''[[lyx_-_programmiersprache:units:hardware:gpio_mmio|std.hardware.gpio_mmio]]'' (''GpioWritePin'') oder ''[[lyx_-_programmiersprache:units:hardware:gpio_pin|std.hardware.gpio_pin]]'' (''GpioOutputPinWrite'') |
| GPIO-Pin als Eingang lesen (Taster, Sensor) | ''[[lyx_-_programmiersprache:units:hardware:gpio_pin|std.hardware.gpio_pin]]'' (''GpioInputPinRead'') |
| LED dimmen / Software-PWM erzeugen | ''[[lyx_-_programmiersprache:units:hardware:gpio_ext|std.hardware.gpio_ext]]'' (''GpioSoftPWM'') |
| Auf Flanke warten (Tasterklick, Interrupt) | ''[[lyx_-_programmiersprache:units:hardware:gpio_ext|std.hardware.gpio_ext]]'' (''GpioWaitForEdge'') |
| Pull-Up / Pull-Down konfigurieren | ''[[lyx_-_programmiersprache:units:hardware:gpio_mmio|std.hardware.gpio_mmio]]'' (''GpioSetPullMode'') |
| Pin auf Alt-Funktion setzen (SPI, I2C, UART) | ''[[lyx_-_programmiersprache:units:hardware:gpio_ext|std.hardware.gpio_ext]]'' (''GpioSetAltMode'') |
| Mehrere Pins atomar setzen (ioctl) | ''[[lyx_-_programmiersprache:units:hardware:gpio_ioctl|std.hardware.gpio_ioctl]]'' (''GpioSetLineValues'' mit mask-Bitmap) |
| GPIO-Chip-Info abfragen (Lines, Name) | ''[[lyx_-_programmiersprache:units:hardware:gpio_ioctl|std.hardware.gpio_ioctl]]'' (''GpioGetChipInfo'') |
| Präzise Mikrosekunden-Wartezeit | ''[[lyx_-_programmiersprache:units:hardware:gpio_util|std.hardware.gpio_util]]'' (''GpioDelayMicroseconds'') |
| BCM2711 Register-Offsets nachschlagen | ''[[lyx_-_programmiersprache:units:hardware:rpi4|std.hardware.rpi4]]'' (nur Konstanten) |
| Übersicht aller GPIO-Units | ''[[lyx_-_programmiersprache:units:hardware:gpio|std.hardware.gpio]]'' |

----

===== Android =====

^ Ich will … ^ Unit ^
| JNI-Typen (JNIEnv, jobject …) | ''[[lyx_-_programmiersprache:units:android:jni|std.android.jni]]'' |
| Logcat-Ausgabe | ''[[lyx_-_programmiersprache:units:android:log|std.android.log]]'' |
| OpenGL ES 2.0 | ''[[lyx_-_programmiersprache:units:android:gles2|std.android.gles2]]'' |
| APK zusammenbauen | ''[[lyx_-_programmiersprache:units:android:apk_builder|std.android.apk_builder]]'' |
| Sensoren (Beschleunigung, Gyroskop) | ''[[lyx_-_programmiersprache:units:android:sensor|std.android.sensor]]'' |
| Netzwerk-Syscalls auf Android | ''[[lyx_-_programmiersprache:units:net:internal:syscalls_android|std.net.internal.syscalls_android]]'' |
| Android vollständiger Guide | → [[lyx_-_programmiersprache:guides:android|Android-Guide]] |
| Übersicht aller Android-Units | ''[[lyx_-_programmiersprache:units:android|std.android]]'' |

----

===== Cloud — AWS & DigitalOcean =====

^ Ich will … ^ Unit ^
| S3-Datei hochladen / herunterladen | ''[[lyx_-_programmiersprache:units:cloud:aws|std.cloud.s3]]'' |
| Große Datei (> 100 MB) nach S3 hochladen | ''[[lyx_-_programmiersprache:units:cloud:aws|std.cloud.s3]]'' (S3PutObjectMultipart) |
| S3-Objekte paginiert auflisten | ''[[lyx_-_programmiersprache:units:cloud:aws|std.cloud.s3]]'' (S3ListAll / S3ListObjectsNext) |
| S3-Teilbereich herunterladen (Range) | ''[[lyx_-_programmiersprache:units:cloud:aws|std.cloud.s3]]'' (S3GetObjectRange) |
| S3-Presigned GET-URL (Download-Link) | ''[[lyx_-_programmiersprache:units:cloud:aws|std.cloud.s3]]'' (S3PresignGet) |
| S3-Presigned PUT-URL (Client-Upload ohne Credentials) | ''[[lyx_-_programmiersprache:units:cloud:aws|std.cloud.s3]]'' (S3PresignPut) |
| Cloudflare R2 via S3-API | ''[[lyx_-_programmiersprache:units:cloud:aws|std.cloud.s3]]'' (S3ConnectR2) |
| MinIO (Self-Hosted S3) | ''[[lyx_-_programmiersprache:units:cloud:aws|std.cloud.s3]]'' (S3ConnectMinio) |
| EC2-Instanz starten / stoppen | ''[[lyx_-_programmiersprache:units:cloud:aws|std.cloud.ec2]]'' |
| DynamoDB-Item lesen / schreiben | ''[[lyx_-_programmiersprache:units:cloud:aws|std.cloud.dynamodb]]'' |
| Lambda-Funktion aufrufen | ''[[lyx_-_programmiersprache:units:cloud:aws|std.cloud.lambda]]'' (LambdaInvoke) |
| SQS-Nachricht senden / empfangen | ''[[lyx_-_programmiersprache:units:cloud:aws|std.cloud.sqs]]'' |
| SNS-Topic-Nachricht / SMS versenden | ''[[lyx_-_programmiersprache:units:cloud:aws|std.cloud.sns]]'' |
| CloudWatch-Metriken schreiben | ''[[lyx_-_programmiersprache:units:cloud:aws|std.cloud.cloudwatch]]'' (CWPutMetricData) |
| AWS-Secret auslesen | ''[[lyx_-_programmiersprache:units:cloud:aws|std.cloud.secrets]]'' (SecretsGetString) |
| SSM-Parameter lesen | ''[[lyx_-_programmiersprache:units:cloud:aws|std.cloud.secrets]]'' (SSMGetParameterValue) |
| IAM-Rolle annehmen (STS AssumeRole) | ''[[lyx_-_programmiersprache:units:cloud:aws|std.cloud.iam]]'' (STSAssumeRole) |
| AWS-Credentials aus Umgebung / Datei laden | ''[[lyx_-_programmiersprache:units:cloud:aws|std.cloud.aws.core]]'' (AWSCredentialsDefault) |
| DigitalOcean Droplet erstellen | ''[[lyx_-_programmiersprache:units:cloud:do|std.cloud.do.droplets]]'' (DropletCreateSimple) |
| DO Block-Storage Volume anhängen | ''[[lyx_-_programmiersprache:units:cloud:do|std.cloud.do.volumes]]'' (VolumeAttach) |
| DO Spaces (S3-kompatibler Speicher) nutzen | ''[[lyx_-_programmiersprache:units:cloud:do|std.cloud.do.spaces]]'' |
| DO Managed Database anlegen | ''[[lyx_-_programmiersprache:units:cloud:do|std.cloud.do.databases]]'' (DatabaseCreate) |
| DO Kubernetes-Cluster anlegen / Kubeconfig | ''[[lyx_-_programmiersprache:units:cloud:do|std.cloud.do.kubernetes]]'' (K8sClusterCreate, K8sKubeconfig) |
| DO App Platform deployen | ''[[lyx_-_programmiersprache:units:cloud:do|std.cloud.do.apps]]'' (AppCreateFromSpec) |
| DO Serverless Function aufrufen | ''[[lyx_-_programmiersprache:units:cloud:do|std.cloud.do.functions]]'' (FunctionInvoke) |
| DO DNS-Record anlegen / aktualisieren | ''[[lyx_-_programmiersprache:units:cloud:do|std.cloud.do.networking]]'' (DomainRecordCreate) |
| DO Load Balancer erstellen | ''[[lyx_-_programmiersprache:units:cloud:do|std.cloud.do.networking]]'' (LBCreate) |
| DO Container Registry nutzen | ''[[lyx_-_programmiersprache:units:cloud:do|std.cloud.do.registry]]'' |
| DO-Credentials aus Umgebung laden | ''[[lyx_-_programmiersprache:units:cloud:do|std.cloud.do.credentials]]'' (DOCredentialsFromEnv) |
| Cloud-Übersicht (AWS + DO) | → ''[[lyx_-_programmiersprache:units:cloud|std.cloud]]'' |
| S3 vollständiger Guide (Upload, Multipart, Presigned, Listing) | → [[lyx_-_programmiersprache:guides:s3|S3-Guide]] |
| Cloud vollständiger Guide | → [[lyx_-_programmiersprache:guides:cloud|Cloud-Guide]] |
| Cloudflare DNS-Record setzen | ''[[lyx_-_programmiersprache:units:cloud:cf|std.cloud.cf.dns]]'' (DNSRecordUpsert) |
| Cloudflare Worker deployen | ''[[lyx_-_programmiersprache:units:cloud:cf|std.cloud.cf.workers]]'' (WorkerDeploy) |
| Cloudflare KV-Store lesen / schreiben | ''[[lyx_-_programmiersprache:units:cloud:cf|std.cloud.cf.kv]]'' (KVGet / KVPutWithTTL) |
| R2-Objekt hochladen (Cloudflare) | ''[[lyx_-_programmiersprache:units:cloud:cf|std.cloud.cf.r2]]'' (R2Upload) |
| D1-SQLite-Datenbank abfragen (Cloudflare) | ''[[lyx_-_programmiersprache:units:cloud:cf|std.cloud.cf.d1]]'' (D1Query) |
| Zone-Cache leeren (Cloudflare) | ''[[lyx_-_programmiersprache:units:cloud:cf|std.cloud.cf.cache]]'' (CachePurgeAll) |
| IP-Adresse sperren / WAF-Regel (Cloudflare) | ''[[lyx_-_programmiersprache:units:cloud:cf|std.cloud.cf.waf]]'' (FirewallBlockIP) |
| Cloudflare Pages deployen | ''[[lyx_-_programmiersprache:units:cloud:cf|std.cloud.cf.pages]]'' (PagesDeployDir) |
| Tunnel ohne offenen Port (Cloudflare) | ''[[lyx_-_programmiersprache:units:cloud:cf|std.cloud.cf.tunnel]]'' (TunnelCreate) |
| Cloudflare-Credentials laden | ''[[lyx_-_programmiersprache:units:cloud:cf|std.cloud.cf.credentials]]'' (CFCredentialsFromEnv) |
| Cloudflare-Übersicht (alle CF-Units) | → ''[[lyx_-_programmiersprache:units:cloud:cf|std.cloud.cf]]'' |

===== Cloud — Google Cloud Platform (GCP) =====

^ Ich will … ^ Unit ^
| GCS-Datei hochladen | ''[[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.storage]]'' (GCSUpload) |
| GCS-Datei herunterladen | ''[[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.storage]]'' (GCSDownload) |
| GCS-Bucket anlegen | ''[[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.storage]]'' (GCSBucketCreate) |
| GCS-Objekte auflisten | ''[[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.storage]]'' (GCSList) |
| GCE-VM anlegen / starten / stoppen | ''[[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.compute]]'' (GCEInstanceCreate / GCEInstanceStart) |
| Auf asynchrone GCE-Operation warten | ''[[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.compute]]'' (GCEOperationWait) |
| Firestore-Dokument schreiben / lesen | ''[[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.firestore]]'' (FSCreate / FSGet) |
| Firestore-Collection auflisten | ''[[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.firestore]]'' (FSList) |
| Pub/Sub-Nachricht publishen | ''[[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.pubsub]]'' (PubSubPublish) |
| Pub/Sub-Nachrichten abrufen und bestätigen | ''[[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.pubsub]]'' (PubSubPull / PubSubAck) |
| Cloud Function deployen | ''[[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.functions]]'' (GCFDeploy) |
| Cloud Function aufrufen | ''[[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.functions]]'' (GCFInvoke) |
| Cloud Run Services auflisten | ''[[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.functions]]'' (GCRServiceList) |
| Log-Eintrag in Cloud Logging schreiben | ''[[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.logging]]'' (LogWrite / LogWriteJSON) |
| Custom Metric in Cloud Monitoring schreiben | ''[[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.logging]]'' (MonWriteMetric) |
| GCP-Secret auslesen | ''[[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.secrets]]'' (SecretGet) |
| GCP-Secret anlegen | ''[[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.secrets]]'' (SecretCreate) |
| IAM Service Account anlegen | ''[[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.secrets]]'' (IAMCreateServiceAccount) |
| GCP-Credentials aus Service-Account-JSON laden | ''[[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.credentials]]'' (GCPCredentialsFromFile) |
| GCP Application Default Credentials laden | ''[[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp.credentials]]'' (GCPCredentialsDefault) |
| GCP-Übersicht (alle GCP-Units) | → ''[[lyx_-_programmiersprache:units:cloud:gcp|std.cloud.gcp]]'' |

----

===== Blockchain =====

^ Ich will … ^ Unit ^
| Eine neue Transaktion erstellen und signieren | ''[[lyx_-_programmiersprache:units:blockchain|std.blockchain]]'' (''BLNewTransaction'', ''BLSignTransaction'') |
| Eine Transaktion verifizieren | ''[[lyx_-_programmiersprache:units:blockchain|std.blockchain]]'' (''BLVerifyTransaction'') |
| Eine Coinbase-Transaktion erstellen (Mining-Belohnung) | ''[[lyx_-_programmiersprache:units:blockchain|std.blockchain]]'' (''BLNewCoinbaseTx'') |
| Einen neuen Block erstellen | ''[[lyx_-_programmiersprache:units:blockchain|std.blockchain]]'' (''BLNewBlock'', ''BLCalculateHash'', ''BLMeetsTarget'') |
| Einen Block minen (PoW) | ''[[lyx_-_programmiersprache:units:blockchain|std.blockchain]]'' (''BLMinePendingTransactions'') |
| TX zum Mempool hinzufügen | ''[[lyx_-_programmiersprache:units:blockchain|std.blockchain]]'' (''BLAddTransaction'') |
| Kontostand einer Adresse abfragen | ''[[lyx_-_programmiersprache:units:blockchain|std.blockchain]]'' (''BLBlockchainGetBalance'') |
| Ledger-Zustand direkt lesen | ''[[lyx_-_programmiersprache:units:blockchain|std.blockchain]]'' (''BLGetBalance'', ''BLGetNonce'') |
| Gesamte Kette auf Gültigkeit prüfen | ''[[lyx_-_programmiersprache:units:blockchain|std.blockchain]]'' (''BLIsValidChain'') |
| Merkle-Root berechnen | ''[[lyx_-_programmiersprache:units:blockchain|std.blockchain]]'' (''BLMerkleRoot'') |
| Big-Endian-Serialisierung für Blockchain-Daten | ''[[lyx_-_programmiersprache:units:blockchain|std.blockchain]]'' (''BLSerializeInt32'', ''BLSerializeInt64'') |
| P2P-Knoten starten und Peers verbinden | ''[[lyx_-_programmiersprache:units:blockchain:p2p|std.blockchain.p2p]]'' (''BLP2PNodeNew'', ''BLP2PNodeStart'', ''BLP2PConnectPeer'') |
| Transaktion an alle Peers broadcasten | ''[[lyx_-_programmiersprache:units:blockchain:p2p|std.blockchain.p2p]]'' (''BLP2PBroadcastTx'') |
| Block an alle Peers broadcasten | ''[[lyx_-_programmiersprache:units:blockchain:p2p|std.blockchain.p2p]]'' (''BLP2PBroadcastBlock'') |
| Eingehende P2P-Nachricht verarbeiten | ''[[lyx_-_programmiersprache:units:blockchain:p2p|std.blockchain.p2p]]'' (''BLP2PHandleIncoming'') |
| Neue Peer-Verbindung akzeptieren | ''[[lyx_-_programmiersprache:units:blockchain:p2p|std.blockchain.p2p]]'' (''BLP2PPoll'') |
| Blockchain-Übersicht (alle Units) | → ''[[lyx_-_programmiersprache:units:blockchain|std.blockchain]]'' |
| Blockchain-Guide (Workflows, P2P, Speicherverwaltung) | → [[lyx_-_programmiersprache:guides:blockchain|Blockchain-Guide]] |

----

===== KassenSichV / TSE =====

^ Ich will … ^ Unit ^
| Kassenbon TSE-signieren (einfach, einstufig) | ''[[lyx_-_programmiersprache:units:kassensichv:manager|kassensichv.manager]]'' (''TseProcessBeleg'') |
| Tischbewirtung / mehrstufigen Vorgang signieren | ''[[lyx_-_programmiersprache:units:kassensichv:manager|kassensichv.manager]]'' (''TseOpenBeleg'' → ''TseCloseBeleg'') |
| QR-Code-String nach BSI TR-03153 erzeugen | automatisch durch ''TseProcessBeleg'' / ''TseCloseBeleg'' in ''SigErgebnis.qrCode'' |
| BelegDaten-Typ und Prozesstyp-Konstanten | ''[[lyx_-_programmiersprache:units:kassensichv:types|kassensichv.types]]'' |
| TSE-Anbindung ohne Hardware testen (CI/CD) | ''[[lyx_-_programmiersprache:units:kassensichv:mock|kassensichv.mock]]'' (''TseMockNew'', Fehlersimulation) |
| Cloud-TSE anschließen (Fiskaly, Deutsche Fiskal) | ''[[lyx_-_programmiersprache:units:kassensichv:rest|kassensichv.rest]]'' (''TseRestNew'', JSON-Config) |
| USB-TSE anschließen (Swissbit, Epson) | ''[[lyx_-_programmiersprache:units:kassensichv:file|kassensichv.file]]'' (''TseFileNew'', base_path) |
| DSFinV-K-Export für Finanzamt-Prüfung | ''[[lyx_-_programmiersprache:units:kassensichv:manager|kassensichv.manager]]'' (''TseExportAuditData'') |
| TSE-Fehler behandeln, offene Transaktionen erkennen | ''[[lyx_-_programmiersprache:units:kassensichv:exceptions|kassensichv.exceptions]]'' |
| KassenSichV-Übersicht (alle Units) | → ''[[lyx_-_programmiersprache:units:kassensichv|kassensichv]]'' |
| KassenSichV-Guide (Workflows, Checkliste, Entscheidungsguide) | → [[lyx_-_programmiersprache:guides:kassensichv|KassenSichV-Guide]] |

----

===== Tipps zur Unit-Auswahl =====

  * **Immer die spezifischste Unit wählen**: ''std.net.https'' statt ''std.net.tls'' + ''std.net.http'' manuell kombinieren — es sei denn, man braucht Kontrolle über den TLS-Handshake.
  * **Für PDF/A**: Die Reihenfolge ist wichtig: ''PdfSetConformance'' → ''PdfGenerateXMP'' → ''PdfSave''.
  * **Für PostgreSQL vs. SQLite**: PostgreSQL wenn mehrere Prozesse gleichzeitig schreiben; SQLite wenn Single-Writer oder Embedded genügt.
  * **epoll vs. poll/select**: ''std.net.epoll'' für > 100 gleichzeitige Verbindungen; ''std.net.socket'' (''Poll'') für kleinere Server.
  * **std.db.redis vs. std.db.redis_simple**: ''redis_simple'' hat keine Abhängigkeit auf ''std.string'' — nützlich für extrem kleine Binaries oder Embedded-Targets.

Letzte Aktualisierung: 2026-06-13 (GCP, Blockchain und CPU/SIMD ergänzt)