Einführung in Daten & Algorithmen – Von den Anfängen der EDV bis hin zu Big Data und den Large Language Modellen in der KI

Published: at 07:00 AMSuggest Changes

Daten & Algorithmen – Eine verständliche Einführung für Entwickler:innen

Wer sich mit Softwareentwicklung beschäftigt, bewegt sich in einem unsichtbaren Geflecht aus Daten & Algorithmen. Fast alles, was ein Computer tut und zwar von der einfachen Rechnenoperation bis hin zum Verständnis natürlicher Sprache, basiert letztlich auf diesen beiden Konzepten. Doch was genau bedeutet das? Und warum sind Daten & Algorithmen heute wichtiger denn je?

In diesem Artikel nehmen wir dich mit auf eine Reise, von den Anfängen der EDV bis hin zu modernen Technologien wie Big Data, Machine Learning und Large Language Models. Alles verständlich und praxisnah erklärt.

EDV – Die Grundlage der digitalen Welt

Die elektronische Datenverarbeitung (EDV) ist seit den 1950er-Jahren ein zentraler Begriff in der digitalen Welt. Damals vor allem im Zusammenhang mit der Automatisierung von Verwaltungsprozessen gedacht, ist EDV heute ein vielschichtiger Begriff für alles, was maschinell mit Daten geschieht: Erfassen, Speichern, Übermitteln, Verarbeiten, Auswerten.

Was in den Anfängen vielleicht nur das Ausdrucken von Lohnabrechnungen oder das Führen von Lagerlisten gedacht war, ist heute die Grundlage von Cloud-Computing, Blockchain, E-Commerce, Online-Banking und künstlicher Intelligenz. Die Bedeutung von Daten ist dabei mit den Jahren exponentiell gewachsen und das nicht zuletzt durch die Digitalisierung fast aller Lebensbereiche.

Dabei beschränkt sich die Auswertung von elektronisch gesammelten, gespeicherten und ausgewerteten Daten schon lange nich mehr nur auf den zivilen Sektor. Unsere aller Public Services, Geheimdienste und Militärs nutzen Daten & Algorithmen schon lange in allen nur möglichen Bereichen ihrer täglichen Arbeit.

Was sind Daten?

Daten sind zunächst einmal nichts anderes als Informationen. In der Informatik sprechen wir meist von strukturierten Daten, also von Informationen, die sich in bestimmte Formen bringen lassen: Zahlen, Texte, Listen, Objekte oder komplexere Konstruktionen wie Graphen oder Bäume. Dabei geht es nicht nur darum, wie Daten gespeichert werden, sondern auch, wie sie verarbeitet und abgerufen werden können.

Im Kontext der Softwareentwicklung unterscheiden wir zwischen einfachen Datentypen wie Strings oder Numbers und komplexeren Datenstrukturen wie Arrays, Maps oder Sets. Doch auch benutzerdefinierte Objekte, JSON-Strukturen oder serverseitige Datenbanken spielen eine zentrale Rolle im täglichen Entwickler:innenalltag.

Ein einfaches Objekt in JavaScript könnte z. B. so aussehen:

const user = {
  name: "Sara",
  age: 29,
  role: "editor"
};

Daten alleine haben jedoch keinen Wert, oder anders ausgedrückt, sie sind von keinerlei praktischen Nutzen, solange sie nicht verarbeitet bzw. ausgewertet werden. Genau hier kommt die EDV und damit die Algorithmen ins Spiel.

Und was sind Algorithmen?

Ein Algorithmus ist im Grunde genommen nichts anderes als eine Schritt-für-Schritt-Anleitung, um ein Problem zu lösen. Ob das nun das Sortieren einer Liste ist, das Durchsuchen einer Datei nach einem Begriff oder das Finden des kürzesten Weges zwischen zwei Punkten. Hinter all diesen Aufgaben steckt ein Algorithmus.

Entscheidend bei Algorithmen ist jedoch nicht nur, dass sie funktionieren, sondern auch, wie effizient sie das tun. Zwei Algorithmen können dasselbe Problem lösen, aber einer davon vielleicht in der Hälfte der Zeit. Was für kleine Datenmengen und selten benötigte Funktionen nicht von Bedeutung sein sollte, kann im umgekehrten Fall, über die Sinnhaftig- und Nutzbarkeit einer Anwendung entscheiden.

Datenstrukturen – Das Rückgrat der Algorithmen

Ohne die passenden Datenstrukturen laufen selbst die besten Algorithmen ins Leere. Ob HashMap, Set, Stack oder Queue, jede Struktur bietet besondere Vorteile für bestimmte Aufgaben.

Wenn du in JavaScript schnelle Zugriffe auf benannte Informationen brauchst, nutzt du typischerweise ein Objekt oder eine Map:

const permissions = new Map();

permissions.set("admin", ["read", "write", "delete"]);
permissions.set("user", ["read"]);

Und wenn du Listen ohne Duplikate brauchst, hilft dir ein Set:

const arr = ["news", "tech", "news"];
const tags = new Set(arr);

console.log(tags); // Set(2) { 'news', 'tech' }
console.log(tags.size); // 2

Die richtige Kombination aus Datenstruktur und Algorithmus macht Programme nicht nur funktional, sondern auch performant und skalierbar. Um Entwickler:innen die Arbeit zu erleichtern, hat es hier immer wieder sehr gute Bibliotheken gegeben, die wichtige Algorithmen “ready to use” zur Verfügung gestellt haben. Beispiele dafür sind “underscore” und “lowdash”. Viele derer Algorithmen sind inzwischen in den JavaScript Standard mit übernommen worden.

Kleiner Tipp am Rande: Solche Bibliotheken und auch andere Projekte, die meist auf GitHub kostenlos zur Verfügung stehen, bieten eine wundervolle Grundlage, seine eigenen Programming Skills zu erweitern. Das Lesen, Nachvollziehen und Verstehen der dort verwendeten Algorithmen erhöht in signifikanter Weise das Verständnis für die verwendete Programmiersprache.

Datenstrukturen und ihre Bedeutung

Die Wahl der richtigen Datenstruktur entscheidet oft über die Performance einer Anwendung. Arrays sind beispielsweise hervorragend geeignet, wenn man Elemente sequenziell verarbeiten will. Will man jedoch häufig nach Elementen suchen, eignen sich HashMaps oder Sets deutlich besser.

Ein klassisches Beispiel in JavaScript ist die Verwendung von Objekten als Maps:

const userMap = {
  "alice": { age: 30, role: "admin" },
  "bob": { age: 24, role: "editor" }
};

console.log(userMap["alice"].role); // Ausgabe: "admin"

Oder ein Set, wenn es um eindeutige Werte geht:

function getUniqueTags(input) {
  const rawTags = input.split(",").map(tag => tag.trim().toLowerCase());

  return new Set(rawTags);
}

// Beispiel:
const userInput = "JavaScript, Web, JavaScript, frontend, web ";
const cleanedTags = getUniqueTags(userInput);

console.log(cleanedTags); // Ausgabe: Set(3) {'javascript', 'web', 'frontend'}
console.log(cleanedTags.size); // 3

Algorithmen – Schritt für Schritt zur Lösung

Ein Algorithmus ist eine präzise Abfolge von Anweisungen, mit der ein bestimmtes Problem gelöst werden kann. Während ein Rezept in der Küche beschreibt, wie man einen Kuchen backt, beschreibt ein Algorithmus in der Informatik, wie man etwa eine Liste sortiert, eine Datei durchsucht oder ein Spiel gewinnt.

Ein einfaches Beispiel ist der klassische Bubble Sort, ein didaktisch wertvoller, aber ineffizienter Sortieralgorithmus. Sortieralgorithmen gehören zu den wichtigsten Grundlagen, die Entwickler:innen kennen sollten. Sie sind nicht nur theoretisch spannend, sondern auch in der Praxis allgegenwärtig.

Ein einfaches Beispiel ist der Bubble Sort. Dieser ist nicht besonders effizient, aber didaktisch nützlich.

function bubbleSort(arr) {
  let swapped;
  do {
    swapped = false;
    for (let i = 0; i < arr.length - 1; i++) {
      if (arr[i] > arr[i + 1]) {
        [arr[i], arr[i + 1]] = [arr[i + 1], arr[i]];
        swapped = true;
      }
    }
  } while (swapped);
  return arr;
}

console.log(bubbleSort([5, 2, 9, 1, 5, 6])); // [1, 2, 5, 5, 6, 9]

Der QuickSort ist oft schneller, aber nicht so stabil. Gleiche Werte können hier schon mal ihre Reihenfolge verlieren.

function quickSort(arr) {
  if (arr.length <= 1) return arr;

  const pivot = arr[arr.length - 1];
  const left = [];
  const right = [];

  for (let i = 0; i < arr.length - 1; i++) {
    if (arr[i] < pivot) {
      left.push(arr[i]);
    } else {
      right.push(arr[i]);
    }
  }

  return [...quickSort(left), pivot, ...quickSort(right)];
}

// Beispiel:
const unsorted = [6, 3, 9, 1, 5];
console.log(quickSort(unsorted)); // [1, 3, 5, 6, 9]

Der MergeSort ist stabil und hat im Worst Case bessere Laufzeit. Er benötigt dafür aber leider mehr Speicher.

function mergeSort(arr) {
  if (arr.length <= 1) return arr;

  const middle = Math.floor(arr.length / 2);
  const left = arr.slice(0, middle);
  const right = arr.slice(middle);

  return merge(mergeSort(left), mergeSort(right));
}

function merge(left, right) {
  const result = [];

  while (left.length && right.length) {
    if (left[0] < right[0]) {
      result.push(left.shift());
    } else {
      result.push(right.shift());
    }
  }

  return [...result, ...left, ...right];
}

// Beispiel:
const unsorted2 = [8, 4, 7, 3, 1];
console.log(mergeSort(unsorted2)); // [1, 3, 4, 7, 8]

Suchalgorithmen wie die binäre Suche sind dagegen hilfreich, wenn Daten bereits sortiert vorliegen.

function binarySearch(arr, target) {
  let left = 0, right = arr.length - 1;
  while (left <= right) {
    const mid = Math.floor((left + right) / 2);
    if (arr[mid] === target) return mid;
    else if (arr[mid] < target) left = mid + 1;
    else right = mid - 1;
  }
  return -1;
}

console.log(binarySearch([1, 2, 4, 6, 7, 9], 6)); // Ausgabe: 3

Wie ihr an diesen einfachen Beispielen sehen könnt, gibt es auch bei Algorithmen oft kein prinzipielles Richtig oder Falsch. Es gilt wie überall die Devise: Nutzt den richtigen Algorithmus für den richtigen Zweck.

Algorithmen in der Praxis

Die „großen“ Algorithmen sind nicht nur etwas für die Uni oder Coding-Challenges. In modernen Anwendungen spielen sie in vielen Bereichen eine entscheidende Rolle.

Ein konkretes Beispiel ist die Filterung großer Datenmengen in Webanwendungen. Wenn Nutzer:innen etwa eine Produktliste nach Preis sortieren oder mit Schlagworten filtern möchten, greifen im Hintergrund algorithmische Prozesse, oft kombiniert mit effizientem Daten-Handling im Frontend.

function filterByKeyword(products, keyword) {
  return products.filter((product) => 
    product.name.toLowerCase().includes(keyword.toLowerCase());
  );
}

Hier ist die Kombination aus Datenstruktur (Array mit Objekten) und einem Filteralgorithmus entscheidend für die User Experience.

Big Data – Wenn Daten explodieren

Big Data beschreibt die Situation, in der Datenmengen so groß, schnelllebig und vielfältig werden, dass klassische Methoden sie nicht mehr verarbeiten können. In einigen Anwendungen fallen millionen von Nutzungsdaten, Sensorwerten, Transaktionen oder sozialen Interaktionen an und müssen verarbeitet werden. Das alles das fällt unter Big Data.

Hier helfen spezialisierte Systeme, z. B. verteilte Datenbanken, Streaming-Algorithmen oder Batch-Prozesse. Ziel ist nicht, Daten nur zu speichern, sondern daraus Nutzen zu ziehen. Dieser Nutzen könnte z.B. darin liegen Trends zu erkennen, Anomalien aufzudecken oder Verhalten zu prognostizieren.

In der Webentwicklung spielt auch hier JavaScript eine entscheidende Rolle. So werden diese auf Dashboards nicht nur in traditionellen Tabellen dargestellt. Sehr beliebt sich hier auch interaktive Visualisierungen mit eigens dafür entwickelten JavaScript Bibliotheken wie z.B. D3.js oder Chart.js.

Machine Learning – Lernen aus Daten

Beim Machine Learning lassen sich Algorithmen auf große Datenmengen „trainieren“, statt sie klassisch zu programmieren. Das bedeutet: Der Algorithmus erkennt Muster selbstständig und verbessert sich mit jedem Durchlauf.

Beispielsweise kann ein ML-Modell lernen, E-Mails als Spam oder Nicht-Spam zu klassifizieren, Bilder zu erkennen oder Texte automatisch zu übersetzen. Voraussetzung dafür sind qualitativ hochwertige, strukturierte Trainingsdaten.

Obwohl das eigentliche Training meist mit Python erfolgt, spielt JavaScript eine Rolle in der Nutzung solcher Modelle im Browser. Das kann z.B. mit Hilfe der JavaScript Bibliothek TensorFlow.js erfolgen.

import * as tf from '@tensorflow/tfjs';

const model = tf.sequential();
model.add(tf.layers.dense({units: 10, inputShape: [3]}));
model.compile({loss: 'meanSquaredError', optimizer: 'sgd'});

Large Language Models – Sprachverstehen auf neuem Niveau

Large Language Models (LLMs) wie GPT oder BERT sind beeindruckende Beispiele dafür, wie weit Datenverarbeitung gehen kann. Diese Modelle werden mit gigantischen Textmengen trainiert. Als Datengrundlage kommen hier z.B. Bücher, Webseiten, Forenbeiträge zum Einsatz zum Einsatz, um daraus daraus z.B. die Struktur, das Kontext und die Bedeutung der dahinter liegenden Informationen zu lernen.

Der Einsatz von LLMs reicht von Chatbots über Texterstellung bis hin zu automatisierten Analysen. Sie sind ein Paradebeispiel für die Verflechtung von Big Data, Machine Learning und algorithmischer Eleganz. Mit ihrer Nutzung geht allerdings auch immer der Aufruf zur Verantwortung: Datenqualität, Transparenz und Fairness sind entscheidende Fragen.

Fazit

Daten & Algorithmen sind keine trockene Theorie, sondern das Fundament jeder ernsthaften Softwareentwicklung. Wer sie versteht, kann nicht nur bessere Programme schreiben, sondern diese auch gezielt optimieren und skalieren. Ob bei der Auswahl der passenden Datenstruktur oder dem Einsatz effizienter Algorithmen, das Wissen darüber hebt den Code von „funktioniert irgendwie“ zu „funktioniert gut, effizient und verständlich“.

Für Entwickler:innen ist es lohnenswert, sich regelmäßig mit den Grundlagen auseinanderzusetzen und diese auch im praktischen Alltag bewusst einzusetzen. JavaScript als flexible Sprache ist dabei ein hervorragender Begleiter, um das theoretische Wissen direkt anzuwenden.

Kleiner Tipp zum Abschluss: Bei den meisten Coding Interviews, bei denen es um eine neue Stellung oder ein neues Projekt geht, drehen sich die entscheidenden Fragen um die Themen Daten & Algorithmen. Das war in der Vergangenheit so, ist altuell so und wird sich auch in Himblick auf ki-unterstützte Entwicklung in der Zukunft nicht ändern.

FAQ – 10 häufig gestellte Fragen zu Daten und Algorithmen (mit JavaScript-Fokus)

Was ist der Unterschied zwischen Daten und Informationen?

In der Softwareentwicklung, insbesondere im Web, sammeln wir oft Rohdaten: Nutzer:inneneingaben, API-Responses, Logdaten. Diese Daten haben noch keine Bedeutung, solange sie nicht ausgewertet werden. In JavaScript kannst du z. B. eine API-Antwort als Daten betrachten:

const response = await fetch("/api/users");
const users = await response.json(); // Daten

Erst wenn du diese Daten z. B. in einer sortierten Tabelle oder Infografiken anzeigst oder analysierst, werden sie zu Information:

const activeUsers = users.filter(u => u.active);

Du veredelst Daten also durch deinen Code in nützliche Information. Das ist essenziell für Dashboards, Statistiken oder Nutzer:inneninteraktionen. Für solche Veredelungen von Daten ist die Verwendung der passenden Algorithmen existentiell wichtig.

Was ist ein Algorithmus in einfachen Worten?

Ein Algorithmus ist eine nachvollziehbare Schrittfolge zur Problemlösung. In JavaScript begegnen dir Algorithmen in vielen Alltagsfunktionen z. B. beim Sortieren einer Liste von Einträgen:

const names = ["Mia", "Jonas", "Lea"];

names.sort(); // Alphabetisch sortiert

Intern nutzt Array.prototype.sort() einen Sortieralgorithmus. Du kannst auch selbst einfache Algorithmen schreiben z. B. zur Berechnung des Durchschnitts:

function average(numbers) {
  const sum = numbers.reduce((a, b) => a + b, 0);

  return sum / numbers.length;
}

Der Fokus liegt auf Wie etwas gelöst wird, nicht nur Was du erreichen willst. Das heisst jedoch nicht, dass wir die Fachlichkeit aus dem Auge verlieren sollten. Die Fachlichkeit sollte immer der Grund unseres Handelns sein. Kein Programm hat einen Selbstzweck.

Warum ist die Wahl der Datenstruktur wichtig?

In JavaScript wie in anderen Programmiersprachen kann dieselbe Aufgabe mit unterschiedlichen Strukturen unterschiedlich effizient gelöst werden. Wenn du z. B. häufig prüfen willst, ob ein bestimmter Wert vorhanden ist, ist ein Set schneller als ein Array, weil es intern eine Hashtabelle verwendet:

const tagsArray = ["html", "css", "javascript"];
console.log(tagsArray.includes("css")); // O(n)

const tagsSet = new Set(["html", "css", "javascript"]);
console.log(tagsSet.has("css")); // O(1)

Gerade bei Filtern, Suchen oder dynamischen Datenmengen (z. B. bei Live-User-Daten in Chats) machen effiziente Strukturen einen spürbaren Unterschied in Performance und Codequalität.

Was genau macht ein Machine-Learning-Algorithmus?

Er lernt aus Daten, ohne explizit programmiert zu sein. In JavaScript kannst du mit Bibliotheken wie TensorFlow.js einfache ML-Modelle sogar im Browser trainieren oder anwenden. Beispiel: Du willst die Tippgeschwindigkeit von Nutzer:innen messen und auf Basis der Daten Feedback geben.

let start = Date.now();
document.querySelector("input").addEventListener("input", () => {
  let speed = (Date.now() - start) / 1000;
  console.log(`Tippgeschwindigkeit: ${speed.toFixed(2)} Sek.`);
});

Das ist noch kein klassischer ML-Algorithmus, aber du könntest diese Daten später analysieren, um aus Mustern Verhalten vorherzusagen, wie z. B. ob jemand eher Anfänger:in oder Fortgeschrittene:r ist.

Was ist der Unterschied zwischen klassischem Programmieren und Machine Learning?

Klassisch: Du schreibst Regeln → der Code entscheidet.

ML: Du gibst Daten → das Modell erkennt Regeln selbst.

In JavaScript kannst du beides kombinieren. Beispiel:

Klassisch:

if (email.endsWith("@firma.de")) {
  userType = "intern";
}

ML-basiert:
Mit einem trainierten Modell, das z. B. aus früheren Nutzer:innenprofilen lernt, würdest du stattdessen so etwas tun:

const prediction = trainedModel.predict(userData); // z. B. "intern" oder "extern"

JavaScript wird oft eingesetzt, um ML-Modelle im Browser zu verwenden oder Ergebnisse im UI (user interface) darzustellen.

Was bedeutet die Big-O-Notation?

Sie beschreibt die „Wachstumsgeschwindigkeit“ eines Algorithmus bei zunehmender Datenmenge. In JavaScript kannst du z. B. vergleichen, wie includes und Set.has skalieren:

const arr = Array(1000000).fill().map((_, i) => i);
console.time("includes");
arr.includes(999999);
console.timeEnd("includes"); // langsam bei großem Array

const set = new Set(arr);
console.time("has");
set.has(999999);
console.timeEnd("has"); // deutlich schneller

Je größer deine Datensätze, desto stärker wirkt sich der Unterschied aus. Das gilt besonders bei Filterlogiken, Tabellen oder Live-Validierungen.

Können auch einfache Websites von Algorithmen profitieren?

Definitiv! JavaScript-Websites enthalten oft kleinere Algorithmen für Interaktivität. Ein typisches Beispiel ist eine Livesuche:

function search(query, data) {
  return data.filter(item =>
    item.toLowerCase().includes(query.toLowerCase())
  );
}

Oder bei Formularvalidierung:

function isValidPassword(pw) {
  return pw.length >= 8 && /\d/.test(pw) && /[A-Z]/.test(pw);
}

Das sind mini-Algorithmen, die aber UX (user experience) und Sicherheit entscheidend verbessern. Auch Animationen, Zufallsfunktionen oder Scrollverhalten basieren auf algorithmischem Denken.

Was ist ein Beispiel für ein Large Language Model im Alltag?

Ein LLM wie ChatGPT kannst du per API in deine Web-App integrieren. So z. B. um automatisch Produktbeschreibungen zu generieren, Support-Antworten vorzuschlagen oder Texte zu analysieren. Beispiel (vereinfachte Struktur).

async function getAIReply(message) {
  const res = await fetch("/api/gpt", {
    method: "POST",
    body: JSON.stringify({ prompt: message }),
  });
  const data = await res.json();
  return data.reply;
}

In JavaScript übernimmst du oft die Rolle der „Schnittstelle“ zwischen User und Modell, wie z. B. in einem Frontend-Chat mit Live-Antworten oder semantischer Suche.

Welche Sprache eignet sich zum Lernen von Algorithmen?

Python ist wegen seiner Lesbarkeit beliebt, aber JavaScript ist ideal, wenn du Webentwickler:in bist. Du kannst direkt im Browser Datenstrukturen ausprobieren, Animationen bauen oder Algorithmen visualisieren. Beispiel: Sortieren einer Tabelle nach Spaltenklick:

function sortTableByColumn(table, columnIndex) {
  const rows = Array.from(table.rows).slice(1);
  rows.sort((a, b) => a.cells[columnIndex].textContent.localeCompare(b.cells[columnIndex].textContent));
  rows.forEach(row => table.tBodies[0].appendChild(row));
}

Solche Snippets kombinieren UI (user interface) und Algorithmus.

Wie kann ich selbst ausreichend gute Daten für Machine Learning erzeugen?

Wenn du z. B. in einem JavaScript-Frontend ein Lernspiel baust und Feedbackdaten wie z.B. Antwortzeit, Fehlerquote und Klickverhalten sammelst, kannst du daraus strukturierte Trainingsdaten machen. Wichtig ist:

Beispielhafte JS-Datenstruktur:

const trainingData = [
  { duration: 4.2, correct: true },
  { duration: 6.8, correct: false },
  { duration: 3.1, correct: true }
];

Diese könntest du später exportieren oder direkt in TensorFlow.js einlesen. Wichtig: Auch das Vorverarbeiten, wie z.B. normalisieren, filtern und validieren, findet oft in entsprechenden JavaScript Algorithmen statt.

Buy me a coffee

Wenn Dir meine Beiträge gefallen und sie Dir bei Deiner Arbeit helfen, würde ich mich über einen “Kaffee” und ein paar nette Worte von Dir freuen.

Buy me a coffee

Next Post
Arrow Functions in JavaScript - Was this hier wirklich bedeutet