Gedächtnis und kognitive Architektur

Die Systeme, die Lernen ermöglichen und begrenzen

Andrew Ellis

11 März, 2026

Was passiert, wenn wir lernen?

Lernen verändert das Langzeitgedächtnis.

Alles, was ins Langzeitgedächtnis gelangen soll, muss durch das Arbeitsgedächtnis.

Das Arbeitsgedächtnis hat enge Grenzen.

Diese drei Sätze erklären einen grossen Teil dessen, was gute Lehre ausmacht.

Gedächtnis ist nicht ein System

Was wir “Gedächtnis” nennen, ist eine Sammlung verschiedener Systeme mit unterschiedlichen Regeln.

System	Kapazität	Dauer	Funktion
Sensorisch	Gross	< 1 Sekunde	Wahrnehmung puffern
Arbeitsgedächtnis	~4 Elemente	15–30 Sekunden	Halten und verarbeiten
Langzeitgedächtnis	Praktisch unbegrenzt	Dauerhaft	Wissen speichern

Das Arbeitsgedächtnis ist der Flaschenhals, durch den alles bewusste Lernen hindurch muss.

Deklaratives Gedächtnis

“Wissen, dass”: bewusst abrufbar, verbalisierbar

Warum erinnern sich Studierende an die lustige Anekdote aus der Vorlesung, aber nicht an den Fachinhalt?

Episodisch: Persönliche Erlebnisse, gebunden an Zeit und Ort

“Die Vorlesung am Dienstag in Raum 204”

Semantisch: Dekontextualisiertes Wissen, Fakten, Konzepte

“Mitochondrien sind die Kraftwerke der Zelle”

Prozedurales Gedächtnis

“Wissen, wie”: automatisiert, schwer verbalisierbar

\(2x + 8 = 14\) nach \(x\) auflösen, ohne die Umformungsregeln erklären zu können

Deklarativ vs. Prozedural

Warum können Studierende eine Methode korrekt beschreiben, aber nicht anwenden?

	Deklarativ	Prozedural
Erwerb	Schnell, durch Erklärung	Langsam, durch Übung
Transfer	Breit (wenn variiert)	Anfangs eng

Man kann niemandem eine Fertigkeit erklären, und man kann niemandem konzeptuelles Verständnis antrainieren. Die meisten Hochschulkurse brauchen beides.

Von Episoden zu Wissen

Der Übergang von episodischem zu semantischem Wissen ist ein zentraler Lernprozess:

Anfangs: “Dienstagvorlesung, Raum 204, das Gewicht-Grösse-Beispiel, rotes Streudiagramm”

Später: “Regression passt eine Gerade an Datenpunkte an, minimiert quadrierte Residuen, setzt lineare Beziehung voraus”

Dieser Übergang erfordert mehrfache Begegnungen in verschiedenen Kontexten, variierende Beispiele und aktiven Abruf. Er geschieht nicht automatisch.

Arbeitsgedächtnis: Der Flaschenhals

Das Arbeitsgedächtnis ist der mentale Arbeitsplatz: Informationen halten und gleichzeitig etwas damit tun.

Eigenschaft	Details
Kapazität	Ca. 4 ± 1 Elemente (Chunks)
Dauer	Zerfällt innerhalb von 15–30 Sekunden ohne Auffrischung
Verarbeitung	Typischerweise wird nur ein Element aktiv bearbeitet

Zwei wichtige Modelle

Baddeley (2000)

Mehrere Subsysteme:

Phonologische Schleife (verbale Info)
Visuell-räumlicher Notizblock (visuelle Info)
Episodischer Puffer (Integration)
Zentrale Exekutive (Steuerung)

Cowan (2010)

Arbeitsgedächtnis = aktivierte Teile des Langzeitgedächtnisses

Aufmerksamkeitsfokus: ~4 Elemente
Vorwissen verändert die effektive Kapazität

Aktivität: Arbeitsgedächtnis erleben

Wir machen ein kurzes Experiment. Wie viele Striche kannst du dir merken?

Klicke auf die Grafik, um die Auflösung zu sehen.

Wie viel passt ins Arbeitsgedächtnis?

Show code

wm_chunking = {
  const w = 900;
  const h = 320;
  const fs = "16px";

  // Letter stroke definitions for "STRICHE"
  // Each letter in a 0..60 x 0..100 coordinate box
  // Each stroke is one continuous line segment of the letter

  const letters = {
    S: [
      [[50,85],[40,100],[15,100],[0,88],[0,72],[10,60],[28,54]],   // top half
      [[28,54],[45,48],[55,35],[55,18],[45,0],[15,0],[5,12]],      // bottom half
    ],
    T: [
      [[0,100],[55,100]],    // top bar
      [[27,100],[27,0]],     // vertical stem
    ],
    R: [
      [[0,0],[0,100]],                                       // vertical stem
      [[0,100],[35,100],[50,90],[50,75],[35,60],[0,60]],     // bowl
      [[30,60],[55,0]],                                      // leg
    ],
    I: [
      [[0,100],[40,100]],    // top serif
      [[20,100],[20,0]],     // vertical stem
      [[0,0],[40,0]],        // bottom serif
    ],
    C: [
      [[55,85],[40,100],[15,100],[0,85],[0,15],[15,0],[40,0],[55,15]], // C curve
    ],
    H: [
      [[0,0],[0,100]],      // left stem
      [[0,55],[55,55]],     // crossbar
      [[55,0],[55,100]],    // right stem
    ],
    E: [
      [[50,100],[0,100]],   // top bar
      [[0,100],[0,0]],      // vertical stem
      [[0,55],[40,55]],     // middle bar
      [[0,0],[50,0]],       // bottom bar
    ],
  };

  const letterOrder = ["S", "T", "R", "I", "C", "H", "E"];
  const letterW = 55;  // width of each letter box
  const gap = 18;      // gap between letters
  const wordW = letterOrder.length * letterW + (letterOrder.length - 1) * gap;
  const wordH = 100;

  // Scale to fit nicely in the SVG (use ~80% of canvas width for 7 letters)
  const targetW = w * 0.82;
  const sc = targetW / wordW;

  // Build all strokes with assembled positions, centered in canvas
  const allStrokes = [];
  const originX = (w - wordW * sc) / 2;
  const originY = (h - wordH * sc) / 2 + wordH * sc; // bottom-left in SVG (y flipped)

  let xOff = 0;
  for (const letter of letterOrder) {
    for (const rawStroke of letters[letter]) {
      const assembled = rawStroke.map(([x, y]) => [
        originX + (x + xOff) * sc,
        originY - y * sc   // flip y for SVG
      ]);
      allStrokes.push({ assembled, letter });
    }
    xOff += letterW + gap;
  }

  // Seeded RNG
  const rng = (function(seed) {
    let s = seed;
    return () => { s = (s * 16807 + 0) % 2147483647; return s / 2147483647; };
  })(42);

  const n = allStrokes.length;

  // Shuffle strokes so scattered view looks truly random
  for (let i = allStrokes.length - 1; i > 0; i--) {
    const j = Math.floor(rng() * (i + 1));
    [allStrokes[i], allStrokes[j]] = [allStrokes[j], allStrokes[i]];
  }

  // Scattered positions: two rows, evenly spaced
  const cols = Math.ceil(n / 2);
  const grid = [];
  for (let r = 0; r < 2; r++) {
    for (let c = 0; c < cols; c++) {
      grid.push([
        w * 0.06 + (w * 0.88) * (c + 0.5) / cols,
        h * 0.32 + r * h * 0.32
      ]);
    }
  }

  // Compute scattered position for each stroke: normalize size, rotate, place on grid
  const targetSize = 70; // uniform size for all strokes
  for (let i = 0; i < n; i++) {
    const s = allStrokes[i];
    const pts = s.assembled;
    const cx = pts.reduce((a, p) => a + p[0], 0) / pts.length;
    const cy = pts.reduce((a, p) => a + p[1], 0) / pts.length;
    // Find bounding box to normalize size
    const xs = pts.map(p => p[0] - cx), ys = pts.map(p => p[1] - cy);
    const extent = Math.max(Math.max(...xs) - Math.min(...xs), Math.max(...ys) - Math.min(...ys), 1);
    const scale = targetSize / extent;
    const angle = Math.floor(rng() * 4) * Math.PI / 2 + (rng() - 0.5) * 0.3;
    const target = grid[i % grid.length];
    s.scattered = pts.map(([px, py]) => {
      const dx = (px - cx) * scale, dy = (py - cy) * scale;
      return [
        dx * Math.cos(angle) - dy * Math.sin(angle) + target[0],
        dx * Math.sin(angle) + dy * Math.cos(angle) + target[1]
      ];
    });
  }

  // SVG
  const svg = d3.create("svg")
    .attr("width", w)
    .attr("height", h)
    .attr("viewBox", `0 0 ${w} ${h}`)
    .style("background", "transparent")
    .style("cursor", "pointer");

  const subtitle = svg.append("text")
    .attr("x", w / 2).attr("y", h - 8)
    .attr("text-anchor", "middle")
    .style("font-size", fs).style("fill", "#6E6560")
    .text(`${n} einzelne Striche`);

  const line = d3.line().curve(d3.curveCatmullRom.alpha(0.5));

  const paths = svg.selectAll("path.stroke")
    .data(allStrokes)
    .join("path")
    .attr("class", "stroke")
    .attr("d", d => line(d.scattered))
    .attr("fill", "none")
    .attr("stroke", "#64748b")
    .attr("stroke-width", 4.5)
    .attr("stroke-linecap", "round")
    .attr("stroke-linejoin", "round");

  let assembled = false;

  svg.on("click", () => {
    assembled = !assembled;

    paths.transition()
      .duration(1200)
      .ease(d3.easeCubicInOut)
      .attr("d", d => line(assembled ? d.assembled : d.scattered))
      .attr("stroke", assembled ? "#1E3A5F" : "#64748b")
      .attr("stroke-width", assembled ? 5.5 : 4.5);

    subtitle.transition().duration(300).style("opacity", 0)
      .transition().delay(assembled ? 800 : 0).duration(300).style("opacity", 1)
      .text(assembled ? "1 Chunk, dieselben Striche" : `${n} einzelne Striche`);

  });

  return svg.node();
}

Elementinteraktivität: Das eigentliche Limit

Beide Aufgaben haben fünf Elemente. Welche ist schwerer, und warum?

A) Fünf Fachbegriffe definieren

B) Dieselben fünf Begriffe in einer Argumentation verknüpfen

Das Limit liegt nicht in der Menge der Elemente, sondern in der Interaktion zwischen ihnen. In Aufgabe B müssen alle Elemente gleichzeitig zueinander in Beziehung gesetzt werden.

	Niedrige Elementinteraktivität	Hohe Elementinteraktivität
Merkmal	Elemente unabhängig lernbar	Elemente müssen gleichzeitig verarbeitet werden
Beispiel	Anatomische Strukturen benennen	Einen Patientenfall differentialdiagnostisch beurteilen

Wenn das Arbeitsgedächtnis so begrenzt ist, was können wir als Lehrende dagegen tun?

Cognitive Load Theory

Die CLT (Sweller 2023) gibt darauf eine konkrete Antwort:

	Intrinsische Last	Extrinsische Last
Quelle	Komplexität des Lernstoffs (Elementinteraktivität)	Wie Material präsentiert wird
Steuerbarkeit	Begrenzt (z.B. durch Sequenzierung)	Durch Design minimierbar
Beispiel	Statistische Interaktion verstehen (viele Konzepte gleichzeitig)	Formel auf Slide 3, Aufgabe auf Slide 17, Erklärung im Handout

Das Ziel: Extrinsische Last reduzieren, um Kapazität freizusetzen für germane processing: die produktive Verarbeitung, die Schemata aufbaut. Germane processing ist der lernrelevante Anteil der Verarbeitung intrinsischer Komplexität.

Verteilung der kognitiven Belastung

Show code

viewof cl_controls = {
  const div = html`<div style="display:flex;flex-direction:column;gap:8px;font-size:15px;">
    <div style="display:flex;align-items:center;gap:10px;">
      <span style="white-space:nowrap;">Extrinsische Belastung: <strong>60%</strong></span>
      <input type="range" min="5" max="70" step="5" value="60" style="width:250px;accent-color:#D55E00;">
    </div>
    <div>
      <button style="padding:4px 14px;font-size:14px;border:1.5px solid #1E3A5F;border-radius:4px;background:transparent;color:#1E3A5F;cursor:pointer;white-space:nowrap;">Gutes Lerndesign</button>
    </div>
  </div>`;

  const slider = div.querySelector("input[type=range]");
  const label = div.querySelector("strong");
  const resetBtn = div.querySelector("button");

  function emit() {
    div.value = +slider.value;
    div.dispatchEvent(new Event("input", { bubbles: true }));
  }

  slider.oninput = () => {
    label.textContent = slider.value + "%";
    emit();
  };

  resetBtn.onclick = () => {
    slider.value = 10;
    label.textContent = "10%";
    emit();
  };

  div.value = 60;
  return div;
}

Show code

cognitive_load_chart = {
  const w = 700;
  const h = 400;

  const intrinsic = 30;
  const ext = Math.min(cl_controls, 100 - intrinsic);
  const learning = Math.max(0, 100 - ext - intrinsic);

  const colors = {
    "Extrinsische Belastung": "#D55E00",
    "Intrinsische Belastung": "#64748b",
    "Lernrelevante Verarbeitung": "#0072B2",
  };

  const data = [
    {type: "Extrinsische Belastung", value: ext, order: 3},
    {type: "Lernrelevante Verarbeitung", value: learning, order: 2},
    {type: "Intrinsische Belastung", value: intrinsic, order: 1},
  ].filter(d => d.value > 0);

  const marks = [
    Plot.barY(data, Plot.stackY({
      x: d => "",
      y: "value",
      fill: "type",
      order: "order",
      tip: true,
      title: d => `${d.type}: ${d.value}%`
    })),
    Plot.ruleY([100], {stroke: "#1A1714", strokeDasharray: "6,4", strokeWidth: 1.5}),
  ];

  if (learning > 8) {
    marks.push(
      Plot.text([{y: intrinsic + learning / 2}],
        {x: d => "", y: "y", text: [`${learning}%`], fill: "white", fontWeight: "bold", fontSize: 16})
    );
  }

  return Plot.plot({
    width: w,
    height: h,
    marginLeft: 60,
    marginBottom: 30,
    marginTop: 30,
    style: {fontSize: "13px", background: "transparent"},
    x: { label: null, padding: 0.7 },
    y: {
      label: "Arbeitsgedächtniskapazität",
      domain: [0, 105],
      ticks: [0, 25, 50, 75, 100],
      tickFormat: d => d + "%"
    },
    color: {
      domain: ["Lernrelevante Verarbeitung", "Intrinsische Belastung", "Extrinsische Belastung"],
      range: [colors["Lernrelevante Verarbeitung"], colors["Intrinsische Belastung"], colors["Extrinsische Belastung"]],
      legend: true
    },
    marks
  });
}

Lernrelevante Verarbeitung (germane processing) ist essentiell für Expertise-Entwicklung. Extrinsische Last sollte minimiert werden, um Raum dafür zu schaffen.

Anstrengend ≠ Komplex

200 Fachbegriffe lernen oder einen Patientenfall analysieren: was ist anstrengender, was ist komplexer?

Nicht jede anstrengende Aufgabe ist komplex (Chen, Paas, und Sweller 2023)

	Anstrengend, nicht komplex	Komplex
Elementinteraktivität	Niedrig	Hoch
Was passiert	Elemente unabhängig lernbar	Elemente interagieren, müssen gleichzeitig verarbeitet werden
Beispiel	Fachvokabular, Periodensystem, Quellenformate	Argumentation aufbauen, Gleichung lösen, Fall analysieren

Die Konsequenz:

Anstrengende Aufgaben brauchen Übung und Wiederholung.
Komplexe Aufgaben brauchen Scaffolding und Sequenzierung. Die Strategien zu verwechseln ist ein häufiger Designfehler.

Was wir jetzt wissen

Gedächtnis = verschiedene Systeme mit unterschiedlichen Regeln

Arbeitsgedächtnis = der Flaschenhals (~4 Elemente, 15–30 Sek.)

Elementinteraktivität = das eigentliche Limit

CLT = extrinsische Last minimieren, um Raum für germane processing zu schaffen

Aktivität: Vertrautheit ≠ Verständnis

Schätze: Wie gut hast du CLT verstanden? (1–5)

Öffne die Kursseite → Tab “Aktivitäten” → Vertrautheit ≠ Verständnis

Als nächstes: Wie entsteht Expertise?

Bibliographie

Baddeley, A. 2000. „The Episodic Buffer: A New Component of Working Memory?“ Trends in Cognitive Sciences 4 (11): 417–23. https://doi.org/10.1016/s1364-6613(00)01538-2.

Chen, Ouhao, Fred Paas, und John Sweller. 2023. „A Cognitive Load Theory Approach to Defining and Measuring Task Complexity Through Element Interactivity“. Educational Psychology Review 35 (2): 63. https://doi.org/10.1007/s10648-023-09782-w.

Cowan, Nelson. 2010. „The Magical Mystery Four: How Is Working Memory Capacity Limited, and Why?“ Current Directions in Psychological Science 19 (1): 51–57. https://doi.org/10.1177/0963721409359277.

Sweller, John. 2023. „The Development of Cognitive Load Theory: Replication Crises and Incorporation of Other Theories Can Lead to Theory Expansion“. Educational Psychology Review 35 (4): 95. https://doi.org/10.1007/s10648-023-09817-2.