Mike Bild

Archiv

198 Beiträge, 2014–2026.

Software198Architektur48KI39Frontend32Methodik28Backend21Delivery19AWS17Node.js17API16Cloud16React15GraphQL14Platform8Daten7Reactive7Python6Publishing5Tools5Produkt4Svelte4Content3Testing3DevOps1Lernen1Observability1Security1Tooling1

202652

  1. Wissen bleibt exportierbar
  2. Releases mit getrennten Prüfgrenzen
  3. Entscheidungen mit Geschichte
  4. Publizieren ohne Öffentlichkeit
  5. Suchen ohne Antworten zu erfinden
  6. Kontrollierte Templates statt Plugins
  7. Finanzen bewusst abtrennen
  8. Wenn Findings zu Wissen werden
  9. Vorschau vor Wirkung
  10. Responsive heißt neu komponieren
  11. WikiKit, SubKit und ContentKit sicher verbinden
  12. MCP, HTTP, Webhooks und A2A einfach erklärt
  13. MCP, HTTP oder Webhook? SubKit, WikiKit und ContentKit verbinden
  14. Ein Cockpit für abgeschlossene Zeitfenster
  15. Zwischenfazit und Systemblick: eine Bilanz der Serie
  16. Publishing mit Claude Code und Codex
  17. Werkzeuge, die zusammenspielen
  18. Semantik vor Geometrie
  19. Diagramme ohne Browser-Laufzeit
  20. Wissens-Lint statt Datenfriedhof
  21. Dashboards aus Markdown-Tabellen
  22. Vom Markdown-Report zur Website
  23. MCP für kuratiertes Wissen
  24. Websites, die Agenten lesen können
  25. Spaces trennen Fachwissen
  26. Widersprüche dürfen bleiben
  27. Headless mit Cockpit und JSON
  28. A2A: Wenn Agenten zusammenarbeiten
  29. Erst prüfen, dann sichtbar
  30. Vom JSON zum privaten Report
  31. Stündlich ist nicht Echtzeit
  32. Custom Fields als Übergabevertrag
  33. Claims: klein, belegt, prüfbar
  34. Produkte berichten über ihre API
  35. Eine Quelle ist noch kein Wissen
  36. Wissensbasen sichtbar machen
  37. WikiKit: Wissen mit Herkunft
  38. Vom Organigramm zur Produktverantwortung
  39. ContentKit: Cockpit und API in einer Domäne
  40. Hilfsmittel, die tragen: Konzepte, Methoden, Prozesse
  41. llms.txt: Doku für Maschinen
  42. Regeln, die halten: der eigene Agent pro Fachdomäne
  43. Agent, Modell, Fachdomäne
  44. MCP: Wenn Software Fähigkeiten anbietet
  45. Wissen, das die Session überlebt
  46. Sauberes Grounding II: Antworten erden
  47. KI im Enterprise-Umfeld: Schnellere Entwicklung braucht andere Prozesse
  48. Sauberes Grounding I: Warum die KI so überzeugend rät
  49. Vergebliche Versuche: Skills, AGENTS.md und die Grenze der Empfehlung
  50. Mein Erfolg lässt sich nicht kopieren
  51. Was ich kritisch sehe
  52. Delegieren statt Diktieren: der Harness macht den Unterschied

20252

  1. Gut genug: das Modell ist selten der Engpass
  2. Vom Werkzeug zur Arbeitsweise

202429

  1. React-Überblick: Von JSX zur Komponentenarchitektur
  2. Formulare in React 19: Actions, useActionState und useOptimistic
  3. React Server Components und Server Actions: Die neue Grenze
  4. React Router Data Router: Die URL als Zustandsort
  5. React Transitions: nicht dringende Updates mit useTransition
  6. React Testing ohne Theater
  7. Suspense und der use-Hook: rendern, als wären die Daten schon da
  8. Client-Zustand vs. Server-Cache: die folgenreichste Grenze im Frontend
  9. Scheduler und virtuelle Zeit testen
  10. GraphQL-Überblick: Vom Schema zur föderierten API
  11. HTTP/2 und Server-Sent Events in Node.js
  12. Markdown Reports statt Dashboard-Zwang
  13. GraphQL Federation: ein Schema aus vielen Subgraphs
  14. Fuzzy Matching mit expliziten Grenzen
  15. Event Sourcing auf AWS: DynamoDB Streams und Lambda
  16. RxJS testen mit Marble-Diagrammen
  17. Rechnungsdaten als Domäne
  18. Node.js testen: die Testpyramide mit Mocha
  19. Deterministische CLIs
  20. Observability mit OpenTelemetry: Logs, Traces und Metriken
  21. Der GraphQL-Client: Apollo Link und Fragments
  22. OCR mit Cache und Misstrauen
  23. Die vier Subject-Typen in RxJS
  24. Apollo Client: der normalisierte Cache und optimistische Updates
  25. GraphQL absichern: Query-Tiefe, Komplexität und Rate-Limiting
  26. TypeScript in Node.js: Setup, Typen und Tests
  27. TypeScript in React: Props, Hooks und Events typisieren
  28. Resilience-Muster: Timeout, Retry, Circuit Breaker, Idempotenz
  29. GraphQL-Subscriptions über SSE: Echtzeit ohne WebSocket-Zwang

202311

  1. Contract Testing statt E2E-Marathon
  2. Fehler als Architektur in Node.js: Netze gegen den Absturz
  3. DORA-Metriken: was Entwicklungszyklen wirklich verkürzt
  4. child_process in Node.js: Skalierung ohne Illusionen
  5. Lambda-Performance und Cold Starts verstehen
  6. RxJS in Node.js: Ereignisströme reaktiv verarbeiten
  7. Evolutionary Architecture: Systeme, die sich ändern dürfen
  8. Von HOCs und Render Props zu Custom Hooks
  9. Async-Kontext in Node.js: AsyncLocalStorage, async_hooks und diagnostics_channel
  10. GraphQL-Auth: Identität im Context, Autorisierung in der Fachlogik
  11. Node.js lokal debuggen und profilieren

202216

  1. Developer Productivity: verkürzte Zyklen bei hoher Qualität
  2. Slots, Context und Web Components in Svelte
  3. Build vs. Runtime in Webprojekten
  4. Streams im Objektmodus: Datenpipelines jenseits von Bytes
  5. Reproduzierbare Testpipelines: kein Flaky, kein Zufall
  6. Adapter-Design: wo Frameworks enden
  7. RxJS in React: Observables im Datenfluss der Oberfläche
  8. Motion, Transitions und Animationen in Svelte
  9. Buffers in Node.js: mit Binärdaten arbeiten
  10. Svelte Stores: Zustand außerhalb der Komponente
  11. Node.js-Streams: Backpressure verstehen und nutzen
  12. Fitness Functions: ausgewählte Architektureigenschaften prüfen
  13. Svelte-Reaktivität: der Compiler statt Virtual DOM
  14. EventEmitter: das Ereignismodell im Kern von Node.js
  15. GraphQL-Paginierung: Cursor, Connections und das Relay-Muster
  16. SvelteKit Adapter AWS: Framework trifft Cloud

202120

  1. Preview-Umgebungen pro Pull Request
  2. Jamstack als Architekturstil für Webanwendungen
  3. Transaktionale E-Mails serverless: SES und Lambda
  4. State-Management in React: Redux Toolkit, leichte Stores, MobX
  5. DynamoDB-Datenmodellierung: Single-Table-Design
  6. CDN Construct: eine kleine Infrastruktur-API
  7. Outcome vor Output: warum Velocity die falsche Zahl ist
  8. Datenanalyse mit NumPy, Pandas und Matplotlib
  9. Wann CQRS und Event Sourcing zu viel sind
  10. GraphQL-Konzepte: Schema, Resolver, Ausführung
  11. GraphQL-APIs mit AppSync und DynamoDB
  12. Context richtig einsetzen: Verteilweg statt heimlicher globaler Zustand
  13. Daten einlesen in Python: CSV, JSON, Excel und Datenbank
  14. Architecture Decision Records: Entscheidungen, die man in zwei Jahren noch versteht
  15. GraphQL-Schema, das mitwächst: Evolution ohne Bruch
  16. Serverless-Workflows mit AWS Step Functions
  17. Event Sourcing: der Event-Store als Logbuch
  18. Flask-Apps testen: der Test-Client und zuverlässige Endpoints
  19. Zustand erhalten und zurücksetzen: React und die Position im Baum
  20. Serverless-Auth mit Cognito User Pools

202016

  1. Trunk-Based Development statt Branch-Friedhof
  2. Wie React den Baum rendert und aktualisiert
  3. Team-Automatisierung mit GitHub Actions
  4. Web-APIs mit Flask: von der App zur JSON-Schnittstelle
  5. Read Models aus Events: Projektionen statt zufälliger Caches
  6. Cloud Guardrails statt Cloud Gatekeeping
  7. CDK Constructs: Abstraktion mit Haftung
  8. Bounded Contexts vor dem Serviceschnitt
  9. Funktionale Muster in Python: Comprehensions, itertools und functools
  10. JSX genau: Die Regeln hinter dem Markup
  11. AWS Deployment Pipelines sind Architektur
  12. Fortgeschrittenes Python: Decorators, Magic Methods und Generatoren
  13. Policy as Code für CDK
  14. Das Aggregat als Konsistenzgrenze
  15. `ssmenv-cli`: kleine CLIs für große Ordnung
  16. GitHub Actions mit AWS CDK

20199

  1. PouchDB und Offline-First
  2. Commands, Events und Queries sauber trennen
  3. Infrastructure as Code braucht Code-Reviews
  4. Secrets im Build sind Produktentscheidungen
  5. Product Discovery vor der ersten Zeile Code
  6. CQRS ist eine fachliche Grenze, kein Framework
  7. Node.js-Training: Vom Event Loop zur Architekturentscheidung
  8. CDK-Anfänge: Infrastruktur mit einer Programmiersprache
  9. AWS Parameter Store im Build

201810

  1. Eine eigene Docker Registry betreiben
  2. Kubernetes-Grundlagen durch Deployment-Druck
  3. Zentrales Logging mit dem ELK-Stack in Docker
  4. Micro-Frontends: Teamschnitt im Browser
  5. Frontend-Schnittstellen sind APIs
  6. Node.js und Redis mit Docker Compose
  7. Containerisierung und die falsche Sicherheit
  8. Meine Arbeitsdefinition für ein MVP: lernen statt halb fertig liefern
  9. GraphQL-Schema in der Fachsprache
  10. Angular, React und der Wert von Übergängen

201711

  1. Prototypen: das Objektmodell hinter JavaScript-Klassen
  2. Redux als Protokoll für UI-Änderungen
  3. JavaScript-Patterns, die geblieben sind: Module, Higher-Order Functions, Currying
  4. WebSockets sind nicht immer die Antwort
  5. KnockoutJS: fein-granulare Reaktivität mit Observables und Computed
  6. PWA Weather: offline ist ein Feature
  7. Tic-Tac-Toe mit Minimax in React
  8. Einfacher Entwurf kann Prozess sparen
  9. HTML5, CSS3 und ECMAScript als Baseline
  10. RxJS: Push und Pull endlich auseinanderhalten
  11. Node.js: Async I/O erklärt Architektur

20167

  1. Babel Node Express: moderne Syntax, altes HTTP
  2. API-Denken vor Framework-Denken
  3. Tyrian Rx React: UI als Datenfluss
  4. GraphQL-Pouch: lokale Daten mit Schema
  5. Definition of Done als Qualitäts-Gate, nicht als Bürokratie
  6. React: Komponenten als Schnittstellen
  7. GraphQL als Frage an das System

20157

  1. Build-Skripte als Produktcode
  2. ES6 Memory: UI-State begreifen
  3. Web Messaging mit RxJS
  4. Funktionale Stile im Alltag
  5. Container sind keine Architektur
  6. Programming Styles als Architekturvergleich
  7. Docker für .NET, bevor es normal war

20148

  1. Tests, bevor es ein Produkt gibt
  2. Flood-It: ein Spiel als Architektur-Lupe
  3. MathParser: Parser als Denkwerkzeug
  4. State Mutation auf Streams
  5. HTTP APIs: klein, stabil, lesbar
  6. Was ich an Elixir gesucht habe
  7. Control Flow vor `async/await`
  8. Warum Katas mehr sind als Fingerübungen