JavaScript Generators: Große Datenmengen schrittweise verarbeiten

JavaScript Generators: Große Datenmengen schrittweise verarbeiten

Von function* und yield über Lazy Evaluation bis zu asynchronen Generatoren und den Iterator-Helfern aus ES2025

Aktualisiert:

Abstract

JavaScript Generators liefern Werte erst bei Bedarf. Sie lernen function*, yield, Iterator-Helfer und for await kennen und sehen, wann sich das lohnt.
  • #JavaScript
  • #Generators
  • #Performance
  • #Entwicklung
  • #Web Development
  • #Iteratoren
  • #Lazy Evaluation
  • #async/await

Warum eine Funktion, die mittendrin anhalten kann, bei großen Datenmengen vor allem Speicher spart

Angenommen, ein Node.js-Skript soll jede Nacht den Umsatzexport eines Webshops auswerten: eine CSV-Datei mit einigen Millionen Zeilen. Die naheliegende Lösung liest die Datei komplett ein, zerlegt sie in ein Array und rechnet dann. Das funktioniert, bis die Datei größer wird als der Arbeitsspeicher, den der Prozess bekommt. Dann bricht das Skript ab, oft mitten in der Nacht.

Die Alternative ist, die Daten wie auf einem Fließband zu behandeln: eine Zeile lesen, verarbeiten, vergessen, die nächste holen. Genau dafür hat JavaScript Generatoren, Funktionen, die mittendrin anhalten und später an derselben Stelle weitermachen. Sie gehören seit ECMAScript 2015 zur Sprache, werden aber im Alltag selten genutzt. Mit den Iterator-Helfern aus ECMAScript 2025 sind sie deutlich bequemer geworden. Dieser Beitrag erklärt die Mechanik, zeigt typische Einsatzfälle und sagt auch, wo Generatoren nichts bringen.

Was eine Generatorfunktion anders macht

Eine normale Funktion läuft von oben nach unten durch und gibt einmal etwas zurück. Eine Generatorfunktion, erkennbar am Stern in function*, liefert beim Aufruf zunächst gar kein Ergebnis. Sie gibt ein Generatorobjekt zurück, und ihr Rumpf hat noch keine einzige Zeile ausgeführt. Erst der Aufruf von next() startet den Code, und zwar bis zum nächsten yield. Dort hält die Funktion an, reicht den Wert nach außen und wartet.

function* zaehler() {
  console.log('Start');
  yield 1;
  console.log('nach dem ersten yield');
  yield 2;
  return 'fertig';
}

const it = zaehler(); // noch keine Ausgabe
console.log(it.next()); // "Start", dann { value: 1, done: false }
console.log(it.next()); // "nach dem ersten yield", dann { value: 2, done: false }
console.log(it.next()); // { value: 'fertig', done: true }
console.log(it.next()); // { value: undefined, done: true }

Jeder Aufruf von next() liefert ein kleines Objekt mit zwei Feldern: value enthält den Wert, done sagt, ob die Funktion zu Ende ist. Lokale Variablen bleiben zwischen den Aufrufen erhalten, weil der Generator seinen Zustand behält. Ein beendeter Generator lässt sich nicht neu starten. Wer die Folge noch einmal braucht, ruft die Generatorfunktion erneut auf und bekommt ein frisches Objekt.

Das Iterator-Protokoll als gemeinsame Sprache

Dass Generatoren so gut in die Sprache passen, liegt am Iterator-Protokoll. Ein Iterator ist jedes Objekt mit einer next()-Methode, die solche value/done-Objekte liefert. Iterierbar ist ein Objekt, das auf Nachfrage einen Iterator herausgibt. Arrays, Strings, Map und Set sind iterierbar, und Generatorobjekte sind beides zugleich.

Deshalb funktionieren Generatoren überall, wo JavaScript eine Folge von Werten erwartet: in for...of-Schleifen, beim Spread-Operator [...gen], bei der Destrukturierung oder in Array.from(). Mit yield* reicht ein Generator alle Werte eines anderen iterierbaren Objekts weiter, etwa eines Arrays oder eines zweiten Generators. Wie for...of sich von den klassischen Schleifen unterscheidet, zeigt der Beitrag zum Vergleich der Schleifen in JavaScript.

Lazy Evaluation: Werte erst berechnen, wenn jemand fragt

Das zentrale Prinzip heißt Lazy Evaluation, auf Deutsch etwa „verzögerte Auswertung“. Ein Generator berechnet einen Wert erst, wenn er angefordert wird. Das erlaubt sogar unendliche Folgen, denn es wird nie mehr erzeugt, als der Aufrufer abholt:

function* rechnungsnummern(start = 1) {
  let n = start;
  while (true) {
    yield `RE-2026-${String(n).padStart(5, '0')}`;
    n += 1;
  }
}

const nummern = rechnungsnummern(42);
console.log(nummern.next().value); // RE-2026-00042
console.log(nummern.next().value); // RE-2026-00043

Die Endlosschleife ist hier kein Fehler. Sie läuft immer nur bis zum nächsten yield und wartet dann, bis jemand die nächste Nummer braucht.

Seine Stärke spielt das Prinzip bei Verarbeitungsketten aus. Angenommen, aus einem Strom von Bestellungen sollen die ersten drei mit einem Betrag über 400 Euro herausgesucht werden. Mit Array-Methoden wie filter() und map() entsteht bei jedem Schritt ein vollständiges Zwischenarray. Generatoren reichen dagegen jeden Datensatz einzeln durch die ganze Kette und hören auf, sobald das Ergebnis feststeht:

function* filtern(quelle, bedingung) {
  for (const wert of quelle) {
    if (bedingung(wert)) yield wert;
  }
}

function* abbilden(quelle, umwandeln) {
  for (const wert of quelle) yield umwandeln(wert);
}

function* nehmen(quelle, anzahl) {
  if (anzahl <= 0) return;
  for (const wert of quelle) {
    yield wert;
    if (--anzahl === 0) return;
  }
}

// Beispieldaten: ein endloser Strom von Bestellungen
function* bestellungen() {
  let id = 1;
  while (true) {
    yield { id, betrag: (id * 37) % 500 };
    id += 1;
  }
}

const grosse = nehmen(
  abbilden(
    filtern(bestellungen(), (b) => b.betrag > 400),
    (b) => `#${b.id}: ${b.betrag} Euro`,
  ),
  3,
);

console.log([...grosse]);
// [ '#11: 407 Euro', '#12: 444 Euro', '#13: 481 Euro' ]

Obwohl die Quelle unendlich ist, erzeugt das Programm genau 13 Bestellungen und hält dann an. Im Speicher liegt zu jedem Zeitpunkt nur ein einziger Datensatz. Mit Arrays wäre dieselbe Aufgabe gar nicht lösbar, weil die Quelle nie vollständig vorläge.

Iterator-Helfer seit ECMAScript 2025

Die verschachtelten Aufrufe im letzten Beispiel lesen sich von innen nach außen und sind entsprechend mühsam. Seit ECMAScript 2025 gibt es dafür eingebaute Methoden direkt am Iterator: map(), filter(), take(), drop(), flatMap(), reduce(), toArray(), forEach(), some(), every() und find(). Sie arbeiten ebenfalls verzögert. Dieselbe Kette sieht damit so aus:

const ergebnis = bestellungen()
  .filter((b) => b.betrag > 400)
  .map((b) => `#${b.id}: ${b.betrag} Euro`)
  .take(3)
  .toArray();

console.log(ergebnis);
// [ '#11: 407 Euro', '#12: 444 Euro', '#13: 481 Euro' ]

Das liest sich wie eine Array-Kette, verhält sich aber anders: filter() und map() laufen erst los, wenn toArray() am Ende Werte anfordert, und take(3) beendet die Kette nach drei Treffern. Mit Iterator.from() lassen sich auch andere iterierbare Objekte in einen Iterator mit diesen Methoden verwandeln:

const summe = Iterator.from([5, 10, 15])
  .map((x) => x * 2)
  .reduce((a, b) => a + b, 0);

console.log(summe); // 60

Die Iterator-Helfer stecken in aktuellen Versionen von Chrome, Edge, Firefox und Safari sowie in Node.js ab Version 22. Wer ältere Browser unterstützen muss, braucht ein Polyfill, etwa aus core-js, oder bleibt bei eigenen Generatorfunktionen wie oben. Für asynchrone Iteratoren gibt es solche Helfer noch nicht im Standard, ein entsprechender Vorschlag ist in Arbeit. Einen Überblick über weitere neue Sprachfunktionen gibt der Beitrag zu den JavaScript-Neuerungen 2025.

Asynchrone Generatoren und for await

Daten kommen selten fertig aus dem Speicher. Meist stammen sie aus einer Datei, einer Datenbank oder einer API, und jedes Stück muss erst abgewartet werden. Dafür gibt es seit ECMAScript 2018 asynchrone Generatoren, geschrieben als async function*. In ihnen darf await stehen, und verbraucht werden sie mit der Schleife for await...of. Wie await grundsätzlich funktioniert, erklärt der Beitrag zu Promises und async/await.

Beispiel: Eine paginierte API Seite für Seite lesen

Viele Schnittstellen liefern große Ergebnismengen in Seiten aus, etwa 100 Kunden pro Abruf und einen Verweis auf die nächste Seite. Ein asynchroner Generator versteckt dieses Blättern vor dem aufrufenden Code:

async function* alleKunden(startUrl) {
  let url = startUrl;
  while (url) {
    const antwort = await fetch(url);
    if (!antwort.ok) {
      throw new Error(`HTTP ${antwort.status} bei ${url}`);
    }
    const { items, next } = await antwort.json();
    yield* items; // jeden Kunden einzeln weiterreichen
    url = next; // null, wenn es keine weitere Seite gibt
  }
}

for await (const kunde of alleKunden('https://api.example.com/kunden?page=1')) {
  if (kunde.id === 120) {
    console.log('Gefunden:', kunde);
    break; // weitere Seiten werden nicht mehr geladen
  }
}

Die Schleife sieht aus, als liefe sie über ein gewöhnliches Array. Tatsächlich lädt der Generator die zweite Seite erst, wenn die erste abgearbeitet ist, und nach dem break gar keine mehr. Das spart Anfragen und schont die API. Die Adresse und das Antwortformat mit items und next sind dabei nur ein Beispiel, echte Schnittstellen benennen die Felder unterschiedlich.

Beispiel: Eine große CSV-Datei zeilenweise auswerten

Zurück zum nächtlichen Umsatzexport. In Node.js sind lesbare Streams asynchron iterierbar, und das Modul readline zerlegt einen Stream in Zeilen. Zusammen mit einem asynchronen Generator entsteht eine Auswertung, deren Speicherbedarf nicht mit der Dateigröße wächst:

import { createReadStream } from 'node:fs';
import { createInterface } from 'node:readline';

async function* csvZeilen(pfad) {
  const zeilen = createInterface({
    input: createReadStream(pfad, { encoding: 'utf8' }),
    crlfDelay: Infinity,
  });
  let kopf;
  for await (const zeile of zeilen) {
    if (!zeile.trim()) continue;
    const felder = zeile.split(';');
    if (!kopf) {
      kopf = felder;
      continue;
    }
    yield Object.fromEntries(kopf.map((name, i) => [name, felder[i]]));
  }
}

let umsatz = 0;
for await (const zeile of csvZeilen('umsaetze.csv')) {
  umsatz += Number(zeile.betrag);
}
console.log(`Umsatz gesamt: ${umsatz.toFixed(2)} Euro`);

Das einfache split(';') genügt für Exporte ohne Trennzeichen in den Feldern. Enthalten Felder Anführungszeichen oder Semikolons, gehört ein richtiger CSV-Parser in die Kette, der Generator-Ansatz bleibt derselbe.

Aufräumen und Fehler behandeln

Wenn eine for...of-Schleife mit break endet oder eine Ausnahme wirft, ruft JavaScript automatisch die Methode return() des Generators auf. Ein finally-Block im Generator läuft dann trotzdem. Das ist der richtige Ort, um Dateien, Verbindungen oder Cursor einer Datenbank zu schließen:

function* zeilenAusDatei() {
  console.log('Datei geöffnet');
  try {
    yield 'Zeile 1';
    yield 'Zeile 2';
    yield 'Zeile 3';
  } finally {
    console.log('Datei geschlossen');
  }
}

for (const zeile of zeilenAusDatei()) {
  console.log(zeile);
  if (zeile === 'Zeile 2') break;
}
// Datei geöffnet, Zeile 1, Zeile 2, Datei geschlossen

Fehler aus dem Inneren eines Generators kommen beim Aufrufer an der Stelle an, an der er next() aufruft, bei Schleifen also in der Schleife. Ein try/catch um die Schleife fängt sie ab. Umgekehrt kann der Aufrufer mit throw() einen Fehler in den Generator hineinwerfen, der dann am wartenden yield auftaucht. Das wird selten gebraucht. Ein Muster aus dem ursprünglichen Beitrag sollten Sie dagegen meiden: Fehler im Generator abzufangen und als gewöhnlichen Wert wie { error: true } weiterzureichen. Der Aufrufer muss dann jeden Wert prüfen, und vergisst er es, rechnet er mit einem Fehlerobjekt weiter. Ausnahmen bis zum Aufrufer durchzulassen, ist in den meisten Fällen klarer.

Was Generatoren bei der Performance bringen und was nicht

Hier lohnt ein nüchterner Blick. Generatoren machen Code nicht schneller im Sinne von mehr Rechenoperationen pro Sekunde. Jeder Wert läuft durch einen Aufruf von next() und ein neues Ergebnisobjekt. Ob und wie stark das gegenüber einer schlichten for-Schleife über ein Array, das ohnehin im Speicher liegt, ins Gewicht fällt, hängt von JavaScript-Engine, Datenmenge und Code ab und lässt sich nur messen, nicht pauschal angeben.

Der Gewinn liegt woanders:

  • Speicher: Es liegt nur der gerade bearbeitete Datensatz im Speicher, nicht die ganze Menge und keine Zwischenarrays.
  • Früher Abbruch: Ketten mit take(), find() oder break hören auf, sobald das Ergebnis feststeht. Bei teuren Quellen wie API-Aufrufen ist das die größte Ersparnis.
  • Frühe Ergebnisse: Der erste Datensatz kann verarbeitet oder angezeigt werden, bevor der letzte geladen ist.
  • Lesbarkeit: Blättern, Puffern und Aufräumen stecken an einer Stelle statt verstreut im aufrufenden Code.

Für Arrays mit einigen Hundert oder Tausend Einträgen, die ohnehin vollständig vorliegen, sind die gewohnten Array-Methoden meist die einfachere Wahl. Wie Sie Engpässe im Browser messen, statt sie zu vermuten, und welche Maßnahmen dort tatsächlich wirken, zeigt der Beitrag JavaScript-Performance optimieren: messen, verstehen, verbessern.

Wann sich Generatoren für Ihr Team lohnen

Unsere Einschätzung: Generatoren sind kein Werkzeug für jede Schleife, aber ein sehr gutes für drei wiederkehrende Aufgaben. Erstens Datenmengen, die nicht sicher in den Speicher passen, wie Exporte, Logdateien oder Datenbankabfragen mit Cursor. Zweitens Quellen, die Stück für Stück ankommen, wie paginierte APIs oder Streams. Drittens Folgen, die theoretisch unendlich sind oder bei denen meist nur der Anfang gebraucht wird.

Mit den Iterator-Helfern ist die größte Hürde gefallen, die umständliche Schreibweise. Teams, die vor allem für aktuelle Browser und Node.js ab Version 22 entwickeln, können verzögerte Verarbeitungsketten heute ohne Bibliothek schreiben. Wichtig ist, die Eigenheiten zu kennen: Ein Generator lässt sich nur einmal durchlaufen, Fehler sollten als Ausnahmen weitergereicht werden, und Aufräumarbeiten gehören in finally. Wer Node.js-Dienste mit großen Datenströmen plant oder ein Team in modernem JavaScript und TypeScript schulen möchte, findet dazu unser Angebot zu TypeScript und Node.js: Beratung, Coaching und Seminare.

Häufige Fragen zu JavaScript Generators

Wie verhalten sich Generatoren zu async/await?

Sie lösen verschiedene Aufgaben. async/await wartet auf einen einzelnen Wert, der später kommt. Ein Generator liefert viele Werte nacheinander. Asynchrone Generatoren verbinden beides: viele Werte, die jeweils abgewartet werden. Bevor es async/await gab, haben Bibliotheken Generatoren genutzt, um asynchronen Code linear zu schreiben. Dafür ist heute async/await die richtige Wahl.

Lässt sich ein Generator zweimal durchlaufen?

Nein. Ein Generatorobjekt ist nach dem ersten Durchlauf erschöpft, ein zweites for...of findet keine Werte mehr. Brauchen Sie die Folge mehrfach, rufen Sie die Generatorfunktion erneut auf oder sammeln die Werte mit toArray() einmalig in einem Array.

Funktionieren Generatoren auch in TypeScript?

Ja. TypeScript kennt die Typen Generator und AsyncGenerator und leitet sie aus Generatorfunktionen meist selbst ab. Für die Iterator-Helfer muss die Konfiguration die passenden Typbibliotheken einbinden, sonst meldet der Compiler die Methoden als unbekannt.

Sind die Iterator-Helfer dasselbe wie Array-Methoden?

Sie heißen ähnlich, arbeiten aber verzögert und ohne Zwischenarrays. Außerdem fehlen einige Array-Methoden, etwa sort() oder reverse(), die naturgemäß alle Werte kennen müssen. Dafür gibt es take() und drop(), die bei Arrays keine Entsprechung haben.

Mehr aus „Programmiersprachen“

PHP-Migration nach PHP2Shell: Upgrade oder Sprachwechsel?

PHP2Shell und das Support-Ende von PHP 8.2: Was Sie jetzt patchen sollten, wie ein Upgrade auf 8.4 oder 8.5 gelingt und wann ein Sprachwechsel sinnvoll ist.

mehr erfahren

Rusts Lieferkette unter Beschuss: Warum ein Angriff nur der Anfang war

Ein Angriff auf Rust-Pakete war im August 2026 schnell gestoppt, das Grundproblem bleibt. Wie crates.io angreifbar ist und was Sie heute dagegen tun können.

mehr erfahren

Programmiersprachen und KI: Warum Rust für Code-Agenten so gut passt

KI-Agenten schreiben in Rust oft verlässlicheren Code, weil der Compiler viele Fehler sofort meldet. Was dahinter steckt und wo das Argument endet.

mehr erfahren

Microsoft und Rust: Was hinter dem Ziel „C und C++ bis 2030“ steckt

Microsoft nutzt Rust im Windows-Kernel, der Ersatz von C und C++ bis 2030 ist aber ein Forschungsziel. Was belegt ist und was es für Entwickler bedeutet.

mehr erfahren

Warum Python, Go und Rust die Zukunft der Softwareentwicklung prägen

Python, Go und Rust teilen sich die Arbeit: Daten und KI, Cloud-Dienste, sichere Systeme. Wo jede Sprache passt, wie sie zusammenwirken und was KI daran ändert.

mehr erfahren

Facebook und PHP: Vom Abschied über HHVM zu Hack

Ein Rückblick von 2025: Wie Facebook PHP mit HipHop, HHVM und Hack umbaute, warum es sich von PHP löste und was davon in PHP selbst ankam.

mehr erfahren

Weitere Blog-Artikel

React Native mit Expo: Von der Idee zur fertigen App

Ein App-Projekt mit React Native und Expo von der Idee bis in den Store: Setup, Expo Router, Daten, Tests, Builds, Einreichung und Updates nach dem Start.

mehr erfahren

JavaScript-Arrays: Best Practices für robusten und schnellen Code

Best Practices für JavaScript-Arrays: Mutation vermeiden, passende Methoden wählen, sortieren und gruppieren, async-Fallen umgehen, mit TypeScript absichern.

mehr erfahren

Java 21: Die wichtigsten Neuerungen der LTS-Version im Überblick

Java 21 brachte Record Patterns, Pattern Matching für switch, Sequenced Collections und Virtual Threads. Der Überblick zeigt Code, Grenzen und heutigen Stand.

mehr erfahren

JavaScript Interop in ASP.NET Core Blazor: Grundlagen und Fehlersuche

JavaScript Interop in Blazor verständlich erklärt: JavaScript aus C# aufrufen, C# aus JavaScript erreichen, Fehler abfangen und beide Seiten debuggen.

mehr erfahren

Mit Expo zur nativen App: Ein Leitfaden für Web-Entwickler

Expo macht React-Wissen für iOS- und Android-Apps nutzbar. Wie Routing, native Module, Builds und Updates funktionieren und wo Web-Teams umdenken müssen.

mehr erfahren

GraphQL in React Native: Apollo Client, Cache und Typen

GraphQL in React Native: wie Sie Apollo Client einrichten, Typen mit GraphQL Code Generator erzeugen, den Cache offline nutzen und Fehler sauber behandeln.

mehr erfahren

Aktuelle Blog-Artikel

PHP-Migration nach PHP2Shell: Upgrade oder Sprachwechsel?

PHP2Shell und das Support-Ende von PHP 8.2: Was Sie jetzt patchen sollten, wie ein Upgrade auf 8.4 oder 8.5 gelingt und wann ein Sprachwechsel sinnvoll ist.

mehr erfahren

Jev: Was ein KI-Modell für schnelles Denken anders macht als ChatGPT

Das System-1-KI-Modell Jev schreibt keinen Text, sondern beantwortet Fragen mit kalibrierten Wahrscheinlichkeiten. Wie das funktioniert und wofür es taugt.

mehr erfahren

Node.js ohne Ballast: 12 Bordmittel, die npm-Pakete ersetzen

Von fetch() über node:test bis Type Stripping: zwölf Node.js-Funktionen, die axios, dotenv, Jest und Co. ersetzen, mit Status in Node 24 und 26 und Grenzen.

mehr erfahren

KI-Agenten verstehen: MCP, A2A, AG-UI und A2UI einfach erklärt

MCP, A2A, AG-UI und A2UI verständlich erklärt: Wie KI-Agenten Werkzeuge nutzen, miteinander arbeiten und Oberflächen erzeugen – und wer die Standards betreut.

mehr erfahren

Rusts Lieferkette unter Beschuss: Warum ein Angriff nur der Anfang war

Ein Angriff auf Rust-Pakete war im August 2026 schnell gestoppt, das Grundproblem bleibt. Wie crates.io angreifbar ist und was Sie heute dagegen tun können.

mehr erfahren

Webentwicklung ohne SPA: Eine Web-App mit V, Veb, SQLite und htmx

Am Beispiel der Meetup-Plattform Clash zeigt sich, wie eine Web-App mit V, Veb, SQLite und htmx ohne SPA-Framework entsteht und wo der Ansatz an Grenzen stößt.

mehr erfahren

React-Performance: Warum weniger Optimierung mehr Tempo bringt

React-Performance heute: Wie Sie mit State am richtigen Ort, dem React Compiler, Transitions, Virtualisierung und Messung Ihre Anwendung spürbar beschleunigen.

mehr erfahren

React-Komponenten verbinden: Welcher Weg passt wann?

Props, Context, Zustand, TanStack Query, URL-Parameter oder Ereignisse: So wählen Sie den passenden Weg, damit zwei React-Komponenten Daten austauschen.

mehr erfahren

KI-Agenten in der Schleife: Loops in Claude Code und Codex

Was ein Loop bei KI-Agenten ist, welche Auslöser es gibt und wie Sie geplante Aufgaben in Claude Code und Codex mit Kostenkontrolle einrichten.

mehr erfahren

JavaScript 2026: Bun, Deno und TypeScript 7 läuten eine neue Ära ein

Node.js, Bun und Deno im Wettbewerb, TypeScript 7 mit Compiler in Go, Build-Werkzeuge in Rust: Was sich 2026 bei JavaScript ändert und was Sie davon übernehmen.

mehr erfahren

npm-Pakete sicher prüfen: So bewerten Sie ein Paket vor dem Einbau

npm-Pakete sicher prüfen: wie Sie Name, Wartung, Provenance, Install-Skripte, bekannte Lücken und Lizenz bewerten, bevor ein Paket in Ihr Projekt kommt.

mehr erfahren

npm install unter der Lupe: Wie Angreifer die Lieferkette kapern

Was npm install technisch tut, welche Angriffsmuster von Typosquatting bis Dependency Confusion es ausnutzen und wie Sie das Installieren absichern.

mehr erfahren

Programmiersprachen und KI: Warum Rust für Code-Agenten so gut passt

KI-Agenten schreiben in Rust oft verlässlicheren Code, weil der Compiler viele Fehler sofort meldet. Was dahinter steckt und wo das Argument endet.

mehr erfahren

Pi Agent vs. Claude Code: minimaler Open-Source-Agent im Vergleich

Pi Agent und Claude Code im Vergleich: Architektur, Erweiterungen, Modellwahl, Lizenz, Kosten und Sicherheit. Für wen sich der Open-Source-Agent lohnt.

mehr erfahren

Agentic Engine Optimization: Websites für KI-Agenten lesbar machen

Agentic Engine Optimization: Wie KI-Assistenten Ihre Website abrufen, welche Rolle robots.txt, llms.txt und strukturierte Daten spielen – und was belegt ist.

mehr erfahren

Claude Skills für Einsteiger: eigene KI-Workflows aufbauen

Claude Skills bündeln wiederkehrende Anweisungen in einer SKILL.md-Datei. So bauen Sie Skills auf und installieren sie in Claude und Claude Code.

mehr erfahren

Claude Code richtig nutzen: 15 Funktionen, die Profis kennen sollten

Claude Code kann mehr als chatten: So setzen Sie CLAUDE.md, Subagenten, Hooks, Skills, MCP und den Headless-Modus gezielt im Entwickleralltag ein.

mehr erfahren

Claude Code für Einsteiger: vom Terminal zur fertigen Anwendung

Claude Code arbeitet im Terminal direkt mit Ihren Dateien. So gelingen Installation, erste Aufträge, Planmodus, Skills und MCP auch ohne Programmiererfahrung.

mehr erfahren

OpenClaw im Praxistest: vom Chatbot zum digitalen Assistenten

OpenClaw macht ein Sprachmodell zum selbst gehosteten Agenten mit Zugriff auf Rechner und Messenger. Aufbau, Einrichtung, Skills und Sicherheitsregeln.

mehr erfahren

Das Ende der Menüs: Wie KI die digitale Arbeitsumgebung verändert

Seit Jahrzehnten bedienen wir Computer über Fenster, Menüs und Ordner. KI-Agenten verschieben das zu Aufträgen in Alltagssprache. Was sich ändert und was nicht.

mehr erfahren

Microsoft und Rust: Was hinter dem Ziel „C und C++ bis 2030“ steckt

Microsoft nutzt Rust im Windows-Kernel, der Ersatz von C und C++ bis 2030 ist aber ein Forschungsziel. Was belegt ist und was es für Entwickler bedeutet.

mehr erfahren

TanStack Start: Das React-Framework als Alternative zu Next.js

TanStack Start ist ein Fullstack-Framework für React auf Basis von TanStack Router und Vite. Was es kann und wann es eine Alternative zu Next.js ist.

mehr erfahren

Die Ralph-Wiggum-Technik: KI-Coding-Agenten, die nicht aufgeben

Die Ralph-Wiggum-Technik lässt einen Coding-Agenten denselben Auftrag wiederholen, bis die Tests bestehen. Wie sie funktioniert und worauf Sie achten sollten.

mehr erfahren

Warum KI Entwickler nicht ersetzt, aber ihre Rolle verändert

KI-Assistenten schreiben heute viel Code. Warum Fachwissen trotzdem wichtiger wird und welche Fähigkeiten Entwickler:innen jetzt gezielt ausbauen sollten.

mehr erfahren

Von Node.js zu Bun: Next.js-Projekte schrittweise umstellen

Wie Sie Bun in Next.js einsetzen: von bun install über bun --bun next dev bis zum Deployment. Was dabei schneller wird, was nicht und was Sie vorher prüfen.

mehr erfahren

Bun erklärt: JavaScript-Laufzeit, Paketmanager und Bundler in einem

Bun ist Laufzeitumgebung, Paketmanager, Bundler und Testrunner in einem. Wie es funktioniert, wie kompatibel es zu Node.js ist und für wen es sich lohnt.

mehr erfahren

KI-Agenten richtig anleiten: Spezifikationen, die funktionieren

Spezifikationen für KI-Coding-Agenten wie Claude Code oder GitHub Copilot: welche Angaben hineingehören, wie Sie Aufgaben aufteilen und Grenzen setzen.

mehr erfahren

Was ist .NET? Die Microsoft-Plattform einfach erklärt

.NET ist Microsofts quelloffene Entwicklungsplattform für Web, Cloud, Desktop und Apps. Sie erfahren, wie Laufzeit, SDK und Versionen zusammenhängen.

mehr erfahren

Künstliche Intelligenz 2026: Vom Chatbot zum digitalen Kollegen

Rückblick auf den KI-Ausblick vom Januar 2026: acht erwartete Trends von Multi-Agenten-Systemen über physische KI und EU AI Act bis zu Quanten-Utility.

mehr erfahren

KI-Jahr 2025: Vier Erkenntnisse und ein Ausblick auf 2026

Rückblick vom Januar 2026 auf das KI-Jahr 2025: vier Entwicklungen von unauffälligen Agenten bis zum Chipmangel und was sie damals für 2026 erwarten ließen.

mehr erfahren

REST und Event-Streams: Wann sich ereignisbasierte Backends lohnen

REST oder Event-Streams? Wie sich Request/Response und Publish/Subscribe unterscheiden, wann Kafka, SSE oder WebSockets passen und wo REST richtig bleibt.

mehr erfahren

Shai-Hulud 2.0: Wie sich ein Wurm im November 2025 durch npm fraß

Shai-Hulud 2.0 einfach erklärt: Rückblick auf den npm-Wurm vom November 2025, wie er Zugangsdaten stahl, sich selbst verbreitete und wie Sie sich schützten.

mehr erfahren

HTMX: Moderne Webanwendungen ohne JavaScript-Framework bauen

HTMX lädt Inhalte nach, sendet Formulare und tauscht Seitenteile per HTML-Attribut aus. Die Anleitung zeigt Browser- und Serverseite und den Stand von HTMX 4.

mehr erfahren

Electron vs. Tauri: Desktop-Apps mit Webtechnik im Vergleich

Electron bringt Chromium und Node.js mit, Tauri nutzt den Webview des Systems und einen Kern in Rust. Der Vergleich zeigt, wann sich welches Framework eignet.

mehr erfahren

Architekturkompetenz im KI-Zeitalter: Was Full-Stack heute heißt

Wenn KI-Werkzeuge Code schreiben, verschiebt sich die Arbeit zu Architekturentscheidungen. Welche Fähigkeiten zählen und wie Sie sie gezielt aufbauen.

mehr erfahren

Omarchy im Test: So macht Linux endlich wieder Spaß

Unser Test von Omarchy aus dem November 2025: Das Linux auf Basis von Arch und Hyprland setzt auf Tastatur, Kachelfenster und abgestimmte Themes.

mehr erfahren

JWT-Probleme: Warum Entwickler vor JSON Web Tokens warnen

JWT-Probleme im Überblick: Warum sich Tokens schwer widerrufen lassen, welche Prüffehler gefährlich sind und wann klassische Sessions die bessere Wahl sind.

mehr erfahren

7 KI-Begriffe erklärt: Von KI-Agenten bis Superintelligenz

Sieben KI-Begriffe von KI-Agenten über RAG und MCP bis Superintelligenz: was sie bedeuten, wie sie zusammenhängen und was davon für Unternehmen zählt.

mehr erfahren

Machine Learning verstehen: von den Grundlagen bis zu moderner KI

Machine Learning verständlich erklärt: welche Lernverfahren es gibt, wie Training mit Daten abläuft und wie Sie prüfen, ob ein Modell wirklich etwas taugt.

mehr erfahren

Scrum-Master-Rolle auf dem Prüfstand: ein Blick aus Architektursicht

Lohnt sich ein Scrum Master noch? Wir betrachten die Rolle aus Sicht der Softwarearchitektur, gleichen sie mit dem Scrum Guide 2020 ab und zeigen Alternativen.

mehr erfahren

Was dürfen wir für Sie tun?

So sind wir zu erreichen: