Big-O-Notation in der Praxis: Laufzeit und Speicher einschätzen

Big-O-Notation in der Praxis: Laufzeit und Speicher einschätzen

Komplexitätsklassen, versteckte Schleifen, Laufzeiten eingebauter JavaScript-Methoden und der Abgleich mit echten Messungen

Aktualisiert:

Abstract

Die Big-O-Notation verständlich erklärt: Komplexitätsklassen, Laufzeit aus Code ablesen, Kosten von JavaScript-Methoden, Speicherbedarf und Messen.
  • #Big O Notation
  • #Algorithmen-Analyse
  • #Zeitkomplexität
  • #Speicherkomplexität
  • #Softwareentwicklung
  • #JavaScript
  • #Datenstrukturen
  • #Performance

Warum Code mit 1.000 Datensätzen flott läuft und mit 100.000 stehen bleibt – und wie Sie das vorher erkennen

Angenommen, ein Mittelständler importiert jede Nacht seine Kundendaten aus dem ERP-System in einen Webshop. Ein kleines Skript prüft vorher, ob E-Mail-Adressen doppelt vorkommen. Im Test mit 1.000 Datensätzen dauert das einen Wimpernschlag. Ein Jahr später sind es 200.000 Datensätze, und der Import läuft plötzlich Minuten statt Sekunden. Am Code hat sich nichts geändert, nur an der Datenmenge.

Genau solche Fälle beschreibt die Big-O-Notation. Sie sagt nicht, wie viele Millisekunden ein Programm braucht, sondern wie sein Aufwand wächst, wenn die Eingabe wächst. Wer sie lesen kann, erkennt die Duplikatprüfung aus dem Beispiel schon im Code-Review als Problem – lange bevor sie im Betrieb auffällt. Die folgenden Abschnitte erklären das Konzept mit lauffähigen JavaScript-Beispielen, zeigen die Kosten gängiger eingebauter Methoden und ordnen ein, wo die Notation an ihre Grenzen stößt.

Was die Big-O-Notation aussagt und was nicht

Die Notation beschreibt eine obere Schranke für das Wachstum. Schreibt man, ein Algorithmus liege in O(n), heißt das: Ab einer gewissen Eingabegröße wächst sein Aufwand höchstens proportional zu n. Dabei steht n für die Größe der Eingabe, etwa die Zahl der Datensätze, der Zeichen in einem Text oder der Knoten in einem Graphen. Welche Größe gemeint ist, sollte man immer dazusagen. Bei zwei Listen unterschiedlicher Länge schreibt man sauberer O(n + m) oder O(n · m) statt alles in ein einziges n zu packen.

Zwei Vereinfachungen machen die Notation handlich. Erstens fallen konstante Faktoren weg: Ein Programm, das jedes Element dreimal anfasst, liegt ebenso in O(n) wie eines, das es einmal anfasst. Zweitens zählt nur der am schnellsten wachsende Term. Aus 3n² + 50n + 1.000 wird O(n²), weil bei großen Datenmengen der quadratische Anteil alles andere überdeckt.

Daraus folgt auch, was die Notation nicht leistet. Sie vergleicht keine absoluten Laufzeiten. Ein O(n)-Verfahren mit hohem konstantem Aufwand kann bei kleinen Listen langsamer sein als ein O(n²)-Verfahren mit sehr billigen Einzelschritten. Big O beantwortet die Frage „Was passiert, wenn die Daten zehnmal so groß werden?“, nicht die Frage „Welche Variante ist heute bei 50 Einträgen schneller?“.

Meist betrachtet man den schlimmsten Fall, also die ungünstigste Eingabe einer bestimmten Größe. Daneben gibt es den durchschnittlichen Fall und die amortisierte Betrachtung, auf die ein eigener Abschnitt weiter unten eingeht. Wer über Komplexität spricht, sollte klarstellen, welche dieser Sichten gemeint ist.

Die wichtigsten Komplexitätsklassen an Beispielen

In der Alltagspraxis begegnen Ihnen vor allem sechs Klassen. Die Tabelle zeigt, wie viele Grundschritte grob anfallen, wenn n von tausend auf eine Million steigt:

KlasseBezeichnungTypisches Beispieln = 1.000n = 1.000.000
O(1)konstantZugriff auf ein Array-Element per Index11
O(log n)logarithmischbinäre Suche in einer sortierten Listeca. 10ca. 20
O(n)lineareine Liste einmal durchlaufen1.0001.000.000
O(n log n)linearithmischgute Sortierverfahrenca. 10.000ca. 20 Millionen
O(n²)quadratischjedes Element mit jedem anderen vergleichen1 Million1 Billion
O(2ⁿ)exponentiellalle Teilmengen einer Menge durchprobierennicht machbarnicht machbar

Der Sprung zwischen den Zeilen ist der eigentliche Lehrstoff. Eine Billion Vergleiche dauert auch auf schneller Hardware viel zu lange für einen interaktiven Webdienst, während 20 Millionen Schritte für einen Sortiervorgang üblich sind.

Die logarithmische Klasse wirkt am wenigsten anschaulich, ist aber leicht zu verstehen: Jeder Schritt halbiert den Suchraum. Das kennt jeder, der in einem gedruckten Telefonbuch geblättert hat. Im Code sieht das so aus:

function binaereSuche(sortiert, gesucht) {
  let links = 0;
  let rechts = sortiert.length - 1;
  let schritte = 0;

  while (links <= rechts) {
    schritte++;
    const mitte = Math.floor((links + rechts) / 2);
    if (sortiert[mitte] === gesucht) return { index: mitte, schritte };
    if (sortiert[mitte] < gesucht) links = mitte + 1;
    else rechts = mitte - 1;
  }
  return { index: -1, schritte };
}

// eine Million gerader Kundennummern: 0, 2, 4, …
const kundennummern = Array.from({ length: 1_000_000 }, (_, i) => i * 2);
console.log(binaereSuche(kundennummern, 1_337_000)); // { index: 668500, schritte: 16 }
console.log(binaereSuche(kundennummern, 3)); // { index: -1, schritte: 20 }

Selbst wenn der gesuchte Wert fehlt, sind nach höchstens 20 Schritten alle Möglichkeiten ausgeschlossen, denn 2²⁰ ist etwas mehr als eine Million. Die Voraussetzung ist allerdings eine sortierte Liste. Muss sie dafür erst sortiert werden, kostet das O(n log n). Das lohnt sich nur, wenn danach viele Suchen folgen.

Laufzeit aus dem Code ablesen

Für eine erste Abschätzung genügen wenige Regeln. Einzelne Anweisungen wie Zuweisungen, Vergleiche oder Rechenoperationen gelten als konstant. Eine Schleife über n Elemente multipliziert den Aufwand ihres Rumpfs mit n. Zwei Schleifen hintereinander addieren sich, zwei ineinander verschachtelte multiplizieren sich. Die Duplikatprüfung aus der Einleitung ist das Lehrbuchbeispiel:

// O(n²): jedes Element wird mit allen folgenden verglichen
function hatDuplikateNaiv(liste) {
  for (let i = 0; i < liste.length; i++) {
    for (let j = i + 1; j < liste.length; j++) {
      if (liste[i] === liste[j]) return true;
    }
  }
  return false;
}

// O(n): ein Set merkt sich, was schon vorkam
function hatDuplikate(liste) {
  const gesehen = new Set();
  for (const wert of liste) {
    if (gesehen.has(wert)) return true;
    gesehen.add(wert);
  }
  return false;
}

const emails = ['a@example.com', 'b@example.com', 'a@example.com'];
console.log(hatDuplikateNaiv(emails), hatDuplikate(emails)); // true true

Die zweite Variante tauscht Speicher gegen Zeit: Das Set belegt im schlimmsten Fall Platz für alle n Werte, dafür entfällt die innere Schleife. Wie ein Set intern nachschlägt und warum das im Mittel in konstanter Zeit gelingt, erklärt unser Beitrag zu Dictionaries und Hash Tables in JavaScript.

Die versteckte Schleife

Tückischer sind Fälle, in denen die zweite Schleife gar nicht als Schleife im Code steht. Methoden wie includes(), indexOf() oder find() durchsuchen ein Array von vorn bis hinten. Stehen sie in einem Callback von filter() oder map(), entsteht unauffällig ein quadratisches Verfahren:

const bestellteArtikel = ['A-100', 'B-200', 'C-300', 'D-400'];
const lagerArtikel = ['B-200', 'D-400', 'E-500'];

// O(n · m): includes() durchsucht lagerArtikel bei jedem Aufruf von vorn
const verfuegbarLangsam = bestellteArtikel.filter((nr) =>
  lagerArtikel.includes(nr),
);

// O(n + m): einmal ein Set aufbauen, dann in konstanter Zeit nachschlagen
const lager = new Set(lagerArtikel);
const verfuegbar = bestellteArtikel.filter((nr) => lager.has(nr));

console.log(verfuegbarLangsam, verfuegbar); // ['B-200', 'D-400'] ['B-200', 'D-400']

Bei vier und drei Einträgen ist der Unterschied bedeutungslos. Bei 50.000 Bestellpositionen und 20.000 Lagerartikeln sind es eine Milliarde Vergleiche gegen rund 70.000 Schritte. Dasselbe Muster steckt oft in Datenbankzugriffen: Eine Abfrage pro Element einer Liste, das sogenannte N+1-Problem, ist ebenfalls eine versteckte Schleife, nur mit deutlich teureren Einzelschritten.

Was eingebaute JavaScript-Methoden kosten

Wer die Komplexität eigenen Codes abschätzt, muss wissen, was die verwendeten Bausteine kosten. Der ECMAScript-Standard schreibt für Arrays keine Laufzeiten vor, die Angaben unten beschreiben das übliche Verhalten der großen Engines wie V8 in Chrome und Node.js. Für Map und Set verlangt der Standard immerhin Zugriffszeiten, die im Mittel sublinear sind, also langsamer wachsen als die Zahl der Elemente.

OperationAufwand
arr[i], arr.at(i), arr.lengthO(1)
push(), pop()O(1) amortisiert
shift(), unshift()O(n), alle Elemente rücken
splice(), toSpliced()O(n)
includes(), indexOf(), find(), some()O(n)
slice(), Spread [...arr], concat()O(n), es entsteht eine Kopie
sort(), toSorted()O(n log n)
Set.prototype.has(), Map.prototype.get()im Mittel O(1)

Zwei Zeilen verdienen besondere Aufmerksamkeit. shift() wirkt harmlos, verschiebt aber den gesamten Rest des Arrays. Wer ein Array als Warteschlange nutzt und vorn entnimmt, landet bei großen Mengen schnell bei quadratischem Gesamtaufwand. Wie sich eine Warteschlange mit konstanten Kosten an beiden Enden bauen lässt, zeigt der Beitrag über FIFO-Queues und Deques in JavaScript. Am Ende eines Arrays dagegen sind push() und pop() billig, weshalb sich ein Array gut als Stapel eignet, wie im Tutorial zum Stack in JavaScript und TypeScript beschrieben.

Die zweite Stelle sind Kopien. Methoden wie toSorted() oder der Spread-Operator erzeugen jedes Mal ein neues Array. Das ist für die Lesbarkeit oft richtig, kostet aber Zeit und Speicher in O(n). Welche Methoden ein Array verändern und welche eine Kopie liefern, sortiert der Beitrag zu Best Practices für JavaScript-Arrays.

Speicherkomplexität: der zweite Preis

Speicher folgt denselben Regeln wie Laufzeit. Gemessen wird in der Regel der zusätzliche Platz, den ein Verfahren neben der Eingabe braucht. Eine Summe über ein Array benötigt O(1) Zusatzspeicher, eine sortierte Kopie O(n), eine Abstandstabelle zwischen allen Paaren von n Orten O(n²). Bei 10.000 Orten sind das bereits 100 Millionen Einträge.

Ein oft übersehener Speicherverbraucher ist die Rekursion. Jeder Funktionsaufruf, der noch nicht beendet ist, belegt einen Eintrag auf dem Aufrufstapel. Eine Rekursion mit Tiefe n braucht deshalb O(n) Speicher, auch wenn im Code keine einzige Liste angelegt wird. Wird die Tiefe zu groß, bricht JavaScript mit einem RangeError ab. Am Beispiel der Fibonacci-Zahlen lässt sich der Tausch von Zeit und Speicher gut zeigen:

// Zeit exponentiell: dieselben Werte werden immer wieder neu berechnet
function fibNaiv(n) {
  return n < 2 ? n : fibNaiv(n - 1) + fibNaiv(n - 2);
}

// Zeit O(n), Speicher O(n): Zwischenergebnisse landen in einer Map
function fibMemo(n, cache = new Map()) {
  if (n < 2) return n;
  if (cache.has(n)) return cache.get(n);
  const ergebnis = fibMemo(n - 1, cache) + fibMemo(n - 2, cache);
  cache.set(n, ergebnis);
  return ergebnis;
}

// Zeit O(n), Speicher O(1): nur die letzten beiden Werte zählen
function fibIterativ(n) {
  let [a, b] = [0, 1];
  for (let i = 0; i < n; i++) [a, b] = [b, a + b];
  return a;
}

console.log(fibNaiv(30), fibMemo(30), fibIterativ(30)); // 832040 832040 832040
console.log(fibMemo(50), fibIterativ(50)); // 12586269025 12586269025

Die naive Fassung ruft sich für n = 30 schon rund 2,7 Millionen Mal selbst auf, für n = 50 wäre sie praktisch unbrauchbar. Das Zwischenspeichern von Ergebnissen, die Memoisierung, macht daraus ein lineares Verfahren, bezahlt mit einer Map. Die iterative Fassung kommt ganz ohne Zusatzspeicher aus. In der Praxis ist die Abwägung selten so eindeutig. Ein Cache, der ohne Obergrenze wächst, wird in einem langlebigen Serverprozess schnell zum Speicherleck.

Schlimmster Fall, Durchschnitt und amortisierte Kosten

Die Angabe „push() ist O(1)“ stimmt nur in einer bestimmten Lesart. Ein dynamisches Array hält intern einen Speicherblock mit Reserve vor. Ist er voll, legt die Engine einen größeren an und kopiert alle Elemente um. Dieser einzelne Aufruf kostet O(n). Weil der Block dabei jeweils um einen Faktor wächst, passiert das so selten, dass die Kosten verteilt auf alle Aufrufe konstant bleiben. Diese Sicht heißt amortisiert.

Bei Hashtabellen wie Map und Set ist es der durchschnittliche Fall, der O(1) ergibt. Im ungünstigsten Fall landen viele Schlüssel im selben Bereich der Tabelle, dann degeneriert das Nachschlagen. Mit den Hashfunktionen moderner Engines kommt das im Alltag praktisch nicht vor. Bei Quicksort ist der Unterschied größer: Im Mittel liegt das Verfahren bei O(n log n), im schlimmsten Fall bei O(n²). Für die eingebaute Sortierung spielt das keine Rolle, denn V8 verwendet seit Jahren TimSort, das auch im schlimmsten Fall bei O(n log n) bleibt.

Für die Praxis heißt das: Bei Diensten, die auf jede einzelne Anfrage schnell antworten müssen, zählt der schlimmste Fall. Bei Stapelverarbeitung über Millionen Datensätze genügt meist die amortisierte oder durchschnittliche Betrachtung.

Messen statt raten: Big O und Benchmarks zusammen

Big O sagt voraus, wie Code skaliert. Ob er bei realen Datenmengen schnell genug ist, zeigt nur eine Messung. Beide Werkzeuge ergänzen sich: Eine Messreihe mit wachsendem n bestätigt oder widerlegt die Abschätzung aus dem Code. Das folgende Beispiel misst die beiden Duplikatprüfungen von oben.

function messe(name, fn) {
  const start = performance.now();
  fn();
  console.log(`${name}: ${(performance.now() - start).toFixed(1)} ms`);
}

for (const n of [5_000, 10_000, 20_000]) {
  const daten = Array.from({ length: n }, (_, i) => i); // keine Duplikate: schlimmster Fall
  messe(`naiv, n = ${n}`, () => hatDuplikateNaiv(daten));
  messe(`Set,  n = ${n}`, () => hatDuplikate(daten));
}

Die absoluten Millisekunden hängen von Rechner und Engine ab. Aufschlussreich ist das Verhältnis: Verdoppelt sich n, sollte sich die Zeit der naiven Variante ungefähr vervierfachen, die der Set-Variante ungefähr verdoppeln. Einzelne Durchläufe schwanken allerdings stark, weil der JIT-Compiler, also der Teil der Engine, der häufig ausgeführten Code zur Laufzeit optimiert, erst nach einigen Wiederholungen greift. Für belastbare Zahlen sollten Sie mehrere Durchläufe machen oder ein Benchmark-Werkzeug wie bench aus Vitest oder die Bibliothek Tinybench nutzen, die Aufwärmrunden und Wiederholungen selbst übernehmen.

Außerdem entscheidet Big O selten allein über die Performance einer Webanwendung. Netzwerk, Datenbankabfragen, Bundle-Größe und Rendering wiegen oft schwerer als ein einzelner Algorithmus. Wie Sie vorgehen, um im Browser die eigentlichen Engpässe zu finden, beschreibt unser Beitrag zur Optimierung der JavaScript-Performance.

Big O im Vorstellungsgespräch und im Code-Review

In technischen Bewerbungsgesprächen gehört die Komplexitätsanalyse weiterhin zum Standard, oft in Form von Programmieraufgaben auf Plattformen wie LeetCode oder HackerRank. Erwartet wird selten die perfekte Lösung auf Anhieb. Bewertet wird vor allem der Weg: zuerst eine einfache, korrekte Lösung, dann eine begründete Aussage zu ihrer Komplexität und schließlich die Frage, ob eine andere Datenstruktur sie verbessert. Wer etwa erklärt, warum ein Set die Duplikatprüfung linear macht und was das an Speicher kostet, zeigt genau das Verständnis, nach dem gefragt wird.

Im Arbeitsalltag ist das Code-Review der wichtigere Ort. Hier lohnt ein Blick auf drei Muster: Suchmethoden innerhalb von Schleifen oder Callbacks, shift() oder unshift() auf langen Arrays sowie Abfragen an Datenbank oder API innerhalb einer Schleife. Alle drei sehen im Code unscheinbar aus und fallen erst mit wachsenden Datenmengen auf.

Auch KI-Assistenten beim Programmieren ändern daran wenig. Sie schlagen häufig funktionierenden Code vor, der bei kleinen Testdaten unauffällig ist. Ob er bei Produktionsdaten trägt, muss weiterhin jemand beurteilen, der die Komplexität lesen kann.

Was das für Ihr Team bedeutet

Die Big-O-Notation ist kein akademischer Selbstzweck, aber auch kein Grund, jeden Code auf die theoretisch beste Klasse zu trimmen. Für die meisten Teams lohnt sich ein pragmatischer Umgang: die gängigen Klassen sicher erkennen, die Kosten der eingesetzten Bibliotheksfunktionen kennen und bei Code, der mit wachsenden Datenmengen arbeitet, die Komplexität im Review ansprechen. Überschätzt wird dagegen die Feinoptimierung kleiner Listen. Bei 50 Einträgen schlägt lesbarer Code fast immer die cleverere Variante.

Wo Datenmengen absehbar wachsen, etwa bei Importen, Berichten oder Suchfunktionen, gehört eine kurze Komplexitätsbetrachtung in den Entwurf. Kombiniert mit Messungen auf realistischen Datenmengen verhindert sie die Sorte Performanceproblem, die erst nach Monaten im Betrieb auffällt und dann teuer wird. Wenn langsame Webanwendungen bereits ein Thema sind, finden Sie auf unserer Seite zur Web-Performance-Beratung unsere Angebote für Analyse, Coaching und Seminare.

Häufige Fragen zur Big-O-Notation

Warum misst man nicht einfach die Laufzeit?

Messungen gelten nur für einen Rechner, eine Engine und eine Datenmenge. Big O beschreibt dagegen das Wachstum unabhängig davon und erlaubt eine Vorhersage für Datenmengen, die es heute noch nicht gibt. Sinnvoll ist beides: die Abschätzung im Entwurf, die Messung zur Bestätigung.

Ist O(n log n) deutlich schlechter als O(n)?

In der Praxis kaum. Der Faktor log n beträgt bei einer Million Elementen etwa 20 und wächst sehr langsam. Deshalb gilt Sortieren als günstig, solange es nicht in einer Schleife wiederholt wird.

Was bedeutet O(1) bei einer Map genau?

Es bedeutet, dass ein Zugriff im Mittel gleich lange dauert, egal ob die Map hundert oder eine Million Einträge enthält. Ein einzelner Zugriff kann trotzdem teurer sein als der Zugriff auf ein Array-Element per Index, weil zuerst der Hashwert des Schlüssels berechnet wird.

Spielt Speicherkomplexität bei heutiger Hardware noch eine Rolle?

Ja, vor allem in Umgebungen mit festen Grenzen. Serverless-Funktionen und Container laufen mit begrenztem Arbeitsspeicher, Browser auf Smartphones ebenso. In der Cloud schlägt sich Speicherbedarf zudem direkt in den Kosten nieder.

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

Barrierefreie Angular-Entwicklung: zugängliche Webanwendungen bauen

Barrierefreiheit in Angular: wie Sie Fokus, dynamische Inhalte und Formulare zugänglich machen, was CDK und Angular Aria beitragen und wie Sie mit axe testen.

mehr erfahren

Virtual Threads in Java: Nebenläufigkeit ohne Thread-Pool-Sorgen

Virtual Threads machen Java-Server fit für viele gleichzeitige Anfragen. Sie erfahren, wie sie arbeiten, was Pinning ist und wie Sie sie in Spring Boot nutzen.

mehr erfahren

Django-Grundlagen: Vom leeren Ordner zum ersten Webprojekt

Django-Einstieg auf aktuellem Stand: Projekt anlegen, Modelle und Migrationen, Admin, Views, Templates, Formulare, Sicherheit ab Werk und Deployment.

mehr erfahren

Django testen: Test-Driven Development mit TestCase und pytest

Testen in Django: TestCase oder pytest-django, Test-Client, Factories, Coverage und CI, erklärt an einem TDD-Beispiel, das Sie Schritt für Schritt nachbauen.

mehr erfahren

Angular i18n: mehrsprachige Anwendungen mit @angular/localize

Internationalisierung in Angular mit @angular/localize: Texte markieren, Plural und Auswahl mit ICU, Übersetzungen extrahieren und je Sprache bauen.

mehr erfahren

Agile Metrics: Welche Kennzahlen agilen Teams wirklich weiterhelfen

Agile Metrics im Überblick: was Cycle Time, Durchsatz, Velocity und DORA-Kennzahlen messen, wie Sie passende auswählen und typische Messfehler vermeiden.

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: