Beiträge von AspirinJunkie

  • Adjustment UDF — Ausgleichungsrechnung für AutoIt

    Adjustment UDF v26.4 — Release Notes

    Dieses Release bringt ein vollständiges interaktives Regressions-Tool als Beispiel, eine deutlich schnellere robuste Schätzung sowie mehrere neue Diagnose- und Statistik-Funktionen. Daneben wurden eine Reihe numerischer und code-technischer Bugs behoben.

    Download: Release v26.4 auf GitHub


    ────────────────────────────────────────
    Highlight: Interactive Regression
    ────────────────────────────────────────

    Das neue Beispiel 'examples/InteractiveRegression.au3' ist ein vollständiges GUI-Tool für Curve-Fitting per Least-Squares. Es kombiniert alle Kernfähigkeiten der UDF in einer kompakten, interaktiv bedienbaren Oberfläche — und ist gleichzeitig als Lernwerkzeug konzipiert: Beim Spielen mit den Modi und Daten lassen sich die Auswirkungen von Fehlerannahmen, Gewichtung und Modellwahl direkt im Plot beobachten.

    Funktionsumfang:

    • Vier Regressionsmodi: Normal (OLS/WLS), Orthogonal (TLS), Deming, York
    • Symbolische Formeleingabe mit automatischer Parameter- und Beobachtungserkennung (z.B. 'A * #X + B')
    • Editierbare Tabellen für Daten und Parameter, mit Tab-/Enter-/Pfeiltasten-Navigation und Excel-kompatiblem Mehrzellen-Paste
    • Live-Plot mit Datenpunkten, gefitteter Kurve, Residuen-Linien und optionalem 1σ/2σ-Konfidenzband (GDI+)
    • Robuste Schätzung mit allen sechs M-Schätzern der UDF
    • CSV-Import (Auto-Erkennung Trennzeichen und Dezimaltrenner) sowie CSV-Export mit Formel-Metadaten (Round-Trip)
    • Vorhersage mit korrekter σ-Propagation
    • Ausreißer-Highlighting basierend auf normierten Verbesserungen
    • "σ · s₀"-Knopf für globale Varianzfaktor-Skalierung der σ-Eingaben


    ────────────────────────────────────────
    Performance: Schnellere robuste Schätzung
    ────────────────────────────────────────

    Iterative Reweighted Least Squares (IRLS) ist bei großen Problemen oder vielen Iterationen der Hauptkostenfaktor. Mehrere Optimierungen reduzieren die Laufzeit deutlich, ohne Genauigkeit zu verlieren:

    • Warm-Start des Gauß-Newton-Innen-Loops zwischen IRLS-Iterationen
    • Begrenzung der inneren GN/LM-Iterationen während Re-Solves
    • Überspringen des State-Resets vor VKS im Single-Pass-Modus
    • Default-Konvergenzgrenze für IRLS gelockert (1e-3 → 1e-2)
    • Cascade-Init (Huber → redescending) als Default deaktiviert, bleibt aber per 'cascadeInit' zuschaltbar


    ────────────────────────────────────────
    Neue Features
    ────────────────────────────────────────

    Statistik

    • Parameter-Korrelationsmatrix abrufbar (compute-on-demand)
    • Konditionszahl der Normalgleichungs-Matrix routinemäßig verfügbar (vorher nur im SVD-Fallback)
    • Sanity-Check 'tr(R) = f' deckt unsichtbar gebrochene Redundanzanteile auf

    Diagnostik

    • Iteratives Data Snooping mit weichem Downweighting (statt harter Ausreißer-Eliminierung)
    • Äußere Zuverlässigkeit (Opt-in): Mindestaufdeckbarkeit 'δ₀ᵢ' und Parameter-Effekt '∇xᵢ' jedes nicht erkannten Ausreißers

    Konvergenz

    • Gradienten-Test '‖g(x)‖ < tol' zusätzlich aktiv, wenn Restriktionen vorhanden sind
    • Parameter-Korrektur-Toleranz skaliert mit der Parameter-Größenordnung (vermeidet falsche Konvergenz bei sehr kleinen Parametern)

    Solver / Robust

    • Cascade-Init Huber → redescending (MM-Estimator) als optionaler Modus
    • Anfänglicher Marquardt-Dämpfungsfaktor 'lmTau' konfigurierbar


    ────────────────────────────────────────
    Bugfixes
    ────────────────────────────────────────

    VKS / Robust

    • Statistiken werden nach VKS-Konvergenz mit den finalen Gewichten aktualisiert
    • σ̂²-Clipping am 'MIN_SIGMA2'-Floor statt Reset auf 1.0
    • Aktiver VKS erzwingt den gewichteten Lösungsweg; geclipptes σ̂² signalisiert den Aufrufer korrekt als Nicht-Konvergenz
    • MAD-Skala nutzt die a-priori 1/σᵢ statt des Whitening-Vektors der laufenden Iteration
    • 'robustParams' werden automatisch auf Defaults gefüllt, wenn der Aufrufer sie auf Null lässt
    • '__adj_initWeights' initialisierte für σ=1 + Multi-VKS-Gruppe keine Gewichte → korrigiert

    Statistik / Diagnostik

    • 'diag(Qvv)' und 'diag(Qŷ)' werden vor 'sqrt' auf 0 gefloort (vermied bisher NaN bei numerischen Negativwerten in Maschinenpräzision)
    • Pope-Statistik nutzt nun korrekt die τ-Verteilung statt Student-t
    • Baarda-/Pope-p-Werte berechnen sich numerisch stabil (keine katastrophale Auslöschung bei großen w/τ)

    Solver

    • LM-Konvergenztest im GLM/CLS-Pfad ist nun residual-basiert ('r2sum') statt parameter-basiert
    • Schrittweiten-Skalierung im numerischen Differentiations-Modus smooth-blendet zwischen den Regimen, statt hart umzuschalten

    API

    • '_adj_setInitialValue' legt fehlende Parameter an, statt zu erroren
    • '_adj_removeObs' setzt '_prepareRunCount' korrekt zurück; vermeidet Crash beim nächsten 'solve'-Aufruf

    Code-Qualität

    • Mehrere undeklarierte Locals in AdjustmentStats / AdjustmentDiagnostics, die in ByRef-Caller leakten, beseitigt
    • Au3Check-Cleanup über alle UDF- und Beispiel-Dateien


    ────────────────────────────────────────
    Kompatibilität
    ────────────────────────────────────────

    Voll abwärtskompatibel zu v26.3.x. Keine API-Änderungen außer Erweiterungen. Default-Verhalten ist identisch — die Performance-relevanten Default-Anpassungen betreffen nur die robuste Schätzung und liegen weiterhin im konservativen Bereich (siehe '_adj_robustDefaults').


    ────────────────────────────────────────
    Download
    ────────────────────────────────────────

    >>> Release v26.4 von GitHub herunterladen <<<

    Quellcode und Issue-Tracker: https://github.com/Sylvan86/autoit-adjustment-udf

  • Adjustment UDF — Ausgleichungsrechnung für AutoIt

    Ok für die Fraktion, für die das (zu Recht) noch etwas zu abstrakt ist, habe ich mal ein weiteres Beispiel dem Example-Ordner hinzugefügt: InteractiveCircleFit.au3 (und das sogar auf deutsch!...)

    Mit dem Skript klickt der User beliebige Punkte auf der Zeichenfläche und das Skript gleicht über diese Punkte einen bestanpassenden Kreis aus.
    Das Beispiel eignet sich meiner Meinung nach sehr gut da man hiermit schnell viele Dinge der Ausgleichungsrechnung visualisieren kann:

    - was sind Beobachtungen, was sind Parameter?
    - was sind diese "Residuen"?
    - was bedeuten die Standardabweichungen?
    - was genau wird da eigentlich "ausgeglichen"?
    - was bedeutet "robuste Ausgleichung"?

    Einfach mal herumspielen damit (neues Release liegt auf Github).

    Hinweis zur Urheberschaft: Da ich nicht so der visuelle Typ bin und von Grafik in AutoIt null Ahnung habe, habe ich mich für dieses Beispielskript intensiv Claude bedient.
    Ich bin vom Ergebnis sehr angetan und freue mich, dass auch Claude die Verwendung meiner UDF komplett verstanden hat.

  • Adjustment UDF — Ausgleichungsrechnung für AutoIt

    Nun ist es soweit: 11 Jahre Arbeit an dieser UDF und nun habe ich ein vorzeigbares Ergebnis.

    Es handelt sich hier nicht um etwas beliebiges was nun auch mal in AutoIt umgesetzt wurde.
    Tatsächlich ist mir kein Projekt wie dieses auch in anderen Sprachen bekannt.
    Die Fähigkeit Usern selbst komplexeste Ausgleichungsrechnung dermaßen simpel zugänglich zu machen ist meines Wissens nach einzigartig.

    Ausgleichungsrechnung war eher eine Nische für Geodäten und Mathematiker. Tatsächlich ist es aber ein derart nützliches Werkzeug bei allen Arten von fehlerbehafteten Daten - sprich: Messungen.
    Was bisher einer weiten Verbreitung entgegenstand war die doch komplexe Mathematik dahinter.
    Genau hier setzt die UDF an in dem sie diesen Aspekt dem User abnimmt. Er muss nur noch sein Problem beschreiben - den Rest macht die UDF.

    Ich empfehle unbedingt das Tutorial mal durchzulesen um einen Eindruck zu bekommen um was es geht.
    Gleichzeitig hoffe ich auf intensive Diskussionen zu euren konkreten Problemen die sich mit dieser UDF lösen lassen.

    Bin ich etwas emotional? Definitiv! Diese UDF ist schon so etwas wie mein Lebenswerk.
    Vom Umfang und fachlicher Tiefe geht es weit über alles hinaus was ich bisher gemacht habe.

  • Adjustment UDF — Ausgleichungsrechnung für AutoIt

    Adjustment UDF — Ausgleichungsrechnung für AutoIt

    Die Ausgleichungsrechnung nach der Methode der kleinsten Quadrate bestimmt aus überbestimmten, widersprüchlichen Beobachtungen die optimalen Werte — und sagt dir dabei genau, wie zuverlässig die Ergebnisse sind. Sie ist die mathematische Grundlage hinter Positionierung, Navigation, Kalibrierung, Fitting, Regression, Signalverarbeitung und praktisch jedem Bereich, in dem Messungen auf die Realität treffen.

    Diese UDF bringt diese Fähigkeit mit einer radikal einfachen Schnittstelle nach AutoIt: Beschreibe dein Modell als String-Formeln, füge Messungen mit ihren Unsicherheiten hinzu und rufe _adj_solve() auf. Keine Matrizenrechnung, keine numerischen Kopfstände, keine externen Tools — nur dein Problem und deine Daten.

    Unter der Haube steckt eine vollständige Ausgleichungsengine auf Basis von OpenBLAS mit nichtlinearen iterativen Lösern, Varianzkomponentenschätzung, robusten Schätzern und vollständiger statistischer Diagnostik — die Art von Werkzeug, die normalerweise MATLAB oder spezialisierter wissenschaftlicher Software vorbehalten ist.

    Download: Aktuelles Release auf GitHub
    GitHub: https://github.com/Sylvan86/autoit-adjustment-udf

    Schnellstart

    Das ist nur der einfachste Fall — ein Mittelwert. Die eigentliche Stärke liegt im gleichzeitigen Ausgleichen verschiedener Messungen mit unterschiedlichen Formeln. Zum Beispiel: Die Position eines Punktes aus Strecken- und Richtungsmessungen bestimmen, oder eine Kurve an Daten anpassen und dabei Nebenbedingungen erzwingen.


    Funktionsübersicht

    Für Experten — der volle Umfang der UDF:

    Modelltypen

    • OLS / WLS / GLS — Überbestimmtes System (gewichtet, generalisiert mit voller Kovarianzmatrix)
    • LSE / WLSE / GLSE — Mit Parameterrestriktionen
    • CLS / WCLS / GCLS — Bedingungsausgleichung
    • GLM / WGLM / GGLM — Gauß-Helmert-Modell (allgemeinste Form)

    Die Modelltyperkennung erfolgt automatisch anhand der Eingabestruktur.

    Löser und Iterationsverfahren

    • Iterationsverfahren: Gauß-Newton, Levenberg-Marquardt (Nielsen-Dämpfung)
    • Linearer Löser: QR-Zerlegung (DGELSY), Singulärwertzerlegung (DGELSD)
    • Jacobi-Matrizen: Numerisch (Zentral, Vorwärts, Rückwärts, Ridder, Higham) oder analytisch
    • Skalierung: Jacobi-Äquilibrierung (automatische Spaltenbalancierung)

    Statistik und Diagnostik

    • Grundstatistiken: A-posteriori-Varianzfaktor s0², Freiheitsgrade, vTPv
    • Genauigkeit: Kofaktormatrix Qxx, Standardabweichungen (Parameter, Beobachtungen)
    • Kontrollierbarkeit: Redundanzanteile r_i, Kofaktormatrizen Qvv und Qy
    • Modellvalidierung: Globaltest (Chi²)
    • Ausreißerdiagnostik: Baarda-Test (w-Statistik), Pope-Test (tau-Statistik), p-Werte, MDB

    Varianzkomponentenschätzung (VKS)

    Helmert-Methode: Separate Varianzfaktoren für verschiedene Beobachtungsgruppen (z.B. Strecken vs. Richtungen). Iterativ bis zur Konvergenz.

    Robuste Schätzung (IRLS)

    • L1 (Median) — Bruchpunkt: 50%
    • Huber (c = 1.345) — Bruchpunkt: ~5%
    • Hampel (a = 1.7, b = 3.4, c = 8.5) — Bruchpunkt: ~25%
    • Biweight (Tukey) (c = 4.685) — Bruchpunkt: 50%
    • BIBER (Schweppe) (c = 3.5) — Bruchpunkt: hebelwertabhängig
    • Modified-M (Koch) (c = 1.5) — Bruchpunkt: hebelwertabhängig

    Skalenparameter: MAD, s0, a priori, benutzerdefiniert.

    Weitere Features

    • Symbolische Formeleingabe als Strings — Parameter und Beobachtungen werden automatisch erkannt
    • Compute-on-Demand — Statistiken werden erst bei Abruf berechnet
    • Konfigurierbare Ergebnisanzeige mit wählbaren Spalten und Abschnitten
    • Ausreißererkennung und -entfernung (_adj_getOutliers, _adj_removeObs)


    Installation

    Voraussetzungen:

    • AutoIt v3.3.16+ (x64)
    • OpenBLAS DLL (libopenblas_x64.dll)

    Einrichtung:

    1. Download: Aktuelles Release von GitHub Releases herunterladen
    2. Entpacken: Dateien in ein Verzeichnis entpacken
    3. OpenBLAS: Die libopenblas_x64.dll wird beim ersten Start automatisch heruntergeladen oder kann manuell ins UDF-Verzeichnis gelegt werden
    4. Einbinden:
    AutoIt
    $__g_hBLAS_DLL = DllOpen("libopenblas_x64.dll")
#include "Adjustment.au3"


    Dokumentation

    Die vollständige Dokumentation ist auf GitHub verfügbar:

    • Tutorial — Schritt-für-Schritt-Anleitung, 9 Kapitel (Einsteiger)
    • Funktionsübersicht — Alle Fähigkeiten auf einen Blick (Alle)
    • API-Referenz — Alle 17 öffentlichen Funktionen (Entwickler)
    • Konfiguration — Löser-, Anzeige- und Robust-Konfiguration (Fortgeschrittene)
    • Ergebnisstruktur — Alle Schlüssel der Ergebnis-Map (Fortgeschrittene)
    • Modelltypen — OLS bis GGLM mit Mathematik (Experten)
    • Löser — GN, LM, QR, SVD im Detail (Experten)
    • Statistik — s0, Qxx, Globaltest, Baarda/Pope (Experten)
    • Robuste Schätzung — IRLS, 6 Schätzer, Gewichtsfunktionen (Experten)
    • Fehlercodes — Alle $ADJ_ERR_* mit Lösungen (Alle)

    Tutorial-Kapitel

    1. Erste Schritte — Was ist Ausgleichungsrechnung?
    2. Erstes Netz — Trilateration
    3. Gewichtung — Messgenauigkeit berücksichtigen
    4. Gemischte Beobachtungen — Strecken und Richtungen kombinieren
    5. Nebenbedingungen — Restriktionen und feste Parameter
    6. Regression — OLS, orthogonal, Deming, York
    7. Kovarianzmatrix — Korrelierte Messungen
    8. Ergebnisse verstehen — Ausgabe konfigurieren und interpretieren
    9. Robuste Schätzung — Umgang mit Ausreißern


    Download

    >>> Aktuelles Release von GitHub herunterladen <<<

    Quellcode und Issue-Tracker: https://github.com/Sylvan86/autoit-adjustment-udf

  • ByRef direkt ohne Leerzeichen hinter dem Komma in einer Function - nicht erlaubt?

    Aus meiner Sicht ist das durchaus ein Bug. Jedoch nicht von AutoIt sondern vom Tool Au3Check, welches oftmals vor AutoIt selbst aufgerufen wird.

    Kann man ganz gut daran erkennen wenn man es deaktiviert indem man am Anfang des Skriptes folgende Zeile setzt: #AutoIt3Wrapper_Run_AU3Check=N - dann läuft das Skript problemlos.

    Ich selbst bin kein Fan von dem meiner Meinung nach ziemlich verbuggten Tool. Das Ding erkennt viel zu viele False-Positives.

  • JIT.au3 - C-Code direkt aus AutoIt kompilieren und ausführen

    Zitat von argumentum

    Ich möchte, dass dieser Code (oder ein funktionierender Code) „sha3_256” hasht.

    Na gut ich habe mal eine Variante gefunden die damit funktionieren könnte (C-Code im Anhang).
    Bei der Umsetzung sind mir aber ein paar Erweiterungen für die JIT.au3 aufgefallen, die hierfür benötigt werden.
    Es ist also mindestens die neue Version v0.2.1 (siehe Link im ersten Post) zu verwenden.

    Dann kann man sich damit eine sha3_256-Funktion in AutoIt folgendermaßen bauen:

  • JIT.au3 - C-Code direkt aus AutoIt kompilieren und ausführen

    Zitat von UEZ

    Apropos testen:

    Grandios! Die Lösung um eben doch sin/cos etc. im C-Code zu verwenden ist ja mal clever!
    Damit erweitert sich die Einsatzmöglichkeit des ganzen enorm! Danke für diesen Ansatz.

    Zitat von argumentum

    Ich möchte, dass dieser Code (oder ein funktionierender Code) „sha3_256” hasht.
    Ich brauche ihn, um die Datei „SQLite.zip” von ihrer Website zu hashen.
    Kann das jemand von Ihnen erledigen? 👼

    Das geht zumindest nicht mit dem gezeigten Code-Schnipsel. Siehe Abschnitt "Limitations" der Readme zur JIT.au3:

    Zitat

    Limitations

    This UDF is designed for small, self-contained code snippets - not for full C projects.

    • No #include support - the C standard library is not available. There is no linker; the code must be fully self-contained.
    • No math.h functions - sin(), cos(), pow() etc. require libm which is not linked. Some GCC __builtin_* functions work as inline alternatives (see examples/example_builtins.au3).
    • Internet required for compilation - use _JIT_LoadBinary to work offline after the first compile.
    • Single translation unit - all code must be in one string, no multi-file compilation.

    Es braucht also einen Code der keine #includes nutzt und spezielle Funktionen evtl. ebenso sparsam einsetzt (wie man das umgehen kann hat UEZ soeben gezeigt).

  • JIT.au3 - C-Code direkt aus AutoIt kompilieren und ausführen

    Zitat von Andy

    Die "neuere" ist nur auf github, nicht in der Download-Datei

    Tatsache! Bin noch neu in dem Metier - hab Releases bisher nicht genutzt. Muss halt dran denken das immer mit zu aktualisieren.
    Sollte nun oben sein.

    Kleine Abfrage: Aktuell ist in $mReturn.ptr der Pointer zum Code-Anfang. In $mReturn.Funcs stehen dann die einzelnen Offsets der Funktionen. Das hat zur Folge, dass man bei DllCallAdress beides für den Pointer braucht. Also z.B. sowas: DllCallAddress("double", $mCode.ptr + $mCode.Funcs["doubleIt"], "DOUBLE", 21.0)

    Wenn man in .Funcs jedoch stattdessen die absoluten Pointer auf die Funktionen stehen hätte, dann könnte man sich das addieren sparen.
    Ich denke daran, statt .Funcs zwei Maps zu verwenden: .FuncOffsets und .FuncPtr . Dann wäre der DllCallAddress-Aufruf schlanker und weniger fehleranfällig.
    Was meint ihr dazu?

  • JIT.au3 - C-Code direkt aus AutoIt kompilieren und ausführen

    Zitat von Andy

    den bekommt man nach dem $mCode = _JIT_Compile($sSourceCode)mit $mCode.BinaryString

    Das ist die "alte" Variante. Hier muss man sich aber selbst um die Offsets für die Funktionen kümmern.
    Da es hier nur eine Funktion gibt ist das aber nicht schädlich (und auf die Art sogar einfacher und kürzer).
    Aber allgemein rate ich nun dazu, stattdessen den String $mCode.ReusableString zu verwenden - dann liefert _JIT_LoadBinary() auch $mCode.Funcs.
    _JIT_LoadBinary() versteht beide Varianten.


    Ansonsten klappt bei mir Andys Version ebenso. Sieht wieder einmal äußerst schick aus :thumbup:

  • JIT.au3 - C-Code direkt aus AutoIt kompilieren und ausführen

    Ich hatte die UDF vor nicht all zu langer Zeit aktualisiert. Schau also mal ob du die aktuelle Version hast.
    Hatte das so umgestellt, dass man direkt die Offsets der Funktionen mit als String erhält und die nicht extra erfassen muss.

    Zitat von UEZ

    $oHTTP.SetProxy(2, "localhost:3128")

    kann doch nicht funktionieren, da $oHTTP doch lokal in den Funktionen definiert wird, oder?

    Doch - ist ne globale. Genau so verwende ich es auch ab und an - daher bin ich mir äußerst sicher, dass das funktioniert (mit NTLM geht es aber glaube ich nicht).

  • JIT.au3 - C-Code direkt aus AutoIt kompilieren und ausführen

    Kompiliert ergibt das folgendes:

    AutoIt
    Global $sBinary = @AutoItX64 _
                  ? '{"b":"RYXAD46DAAAAQVRVV1aJ1lOF0n5wSInLRInHMclFMcBMY9pmZi4PH4QAAAAAAGaQRInARI0UiTHSTI0Mgw8fAInNjQRSMdVEMdBBiewPtsDB5QdBweQQgeUA/wAAQYHkAAD/AEQJ4AnoDQAAAP9BiQSRSIPCAUk503XFg8EBQQHwOc91q1teX11BXMPD","f":{"XorTexture":0}}' _
				  : '{"b":"VVdWU4PsBItUJCCF0n5xi0QkHIXAfmmLRCQci3wkGDH2jRyFAAAAAIkcJC6NdCYAjSy2MdIujbQmAAAAAI12AInRjRxSMfEx64nID7bbweEHweAQgeEA/wAAJQAA/wAJ2AnIDQAAAP+JBJeDwgE5VCQcdcyDxgEDPCQ7dCQgdbCDxARbXl9dwgwA","f":{"XorTexture":0}}'
Global $mCode = _JIT_LoadBinary($sBinary)

    Kompilieren klappt aber dann passiert nicht viel bei mir.

    Zitat von UEZ

    Vielleicht kann man ein Proxy mitgeben...

    Kann man:

    AutoIt
    #include "JIT.au3"
$oHTTP.SetProxy(2, "localhost:3128")

  • JIT.au3 - C-Code direkt aus AutoIt kompilieren und ausführen

    Zitat von Andy

    andere als C++-Compiler via _JIT_Compile() von der godbolt-Website einzusetzen

    Eigentlich gut möglich, jedoch müsste man sich dort das Thema der Relokationen nochmal genauer ansehen. Ich habe das ja durch eine manuelle Ersetzung realisiert. Ob die Bezeichnungen bei den anderen Compilern da gleich sind weiß ich nicht, da ich erstmal nur auf den GCC hin implementiert habe.

    Zitat von Andy

    Ich fände es besser, den C-Code direkt "inline" anzusprechen, wesentlich einfacher zu schreiben und zu debuggen.

    Dann bräuchte es aber eine Art Präprozessor der die au3-Datei entsprechend aufarbeitet.
    Das könnte man durchaus als ein Zusatzfeature mit einbauen.
    Ansonsten teile ich aber deine Grundproblem mit den Multi-Line-Strings in AutoIt: die sind einfach Mist.

  • JIT.au3 - C-Code direkt aus AutoIt kompilieren und ausführen

    Mal als Ergänzung: Ich hatte AutoIt allgemein längere Zeit liegen gelassen.
    Aber tatsächlich hat der Einsatz von KI da den Spaß wieder entflammt bei mir.
    Die Idee und technische Umsetzung bekomme ich bei den allermeisten Dingen hin.
    Aber was wirklich abfu**t ist der ganze Scheiß drumherum: Ordentlich formatieren, kommentieren, beschreiben, Codeverwaltung, Beispiele erstellen etc.
    Genau hier ist für mich KI bislang der absolute Game-Changer so dass ich mich jetzt wirklich nur auf den Teil konzentrieren kann der wirklich Spaß macht.