Lernziele, Schemata und Vorwissen

Warum dieselbe Aufgabe nicht für alle dieselbe Aufgabe ist

28 August, 2026

Gleiche Hardware, unterschiedliche Software

Warum können manche Menschen komplexe Probleme mühelos lösen, obwohl das Arbeitsgedächtnis bei allen begrenzt ist?

Dimension	Anfängerinnen und Anfänger	Expertinnen und Experten
Sehen	einzelne Teile	bedeutungsvolle Muster
Verarbeiten	Schritt für Schritt	automatisierte Prozeduren
Wissen	isolierte Fakten	vernetzte Schemata

Expertise beruht auf organisiertem Wissen im Langzeitgedächtnis, nicht auf einem grösseren Arbeitsgedächtnis (Sweller 2023).

Kern: Expertinnen und Experten bündeln einzelne Elemente zu bedeutungsvollen Mustern. Dadurch verändert Vorwissen die effektive Belastung einer Aufgabe.

Überleitung: Die folgende Darstellung zeigt den Unterschied zwischen isolierten Elementen und organisierten Schemata.

Schemata organisieren Wissen

schemas_width = 960
schemas_height = 500
schemas_font_size = "15px"

novice_expert_schemas = {
  const w = schemas_width;
  const h = schemas_height;
  const fs = schemas_font_size;

  // Colors (Okabe-Ito)
  const colNeg = "#D55E00";   // negative/novice
  const colPos = "#0072B2";   // positive/expert
  const colNeutral = "#64748b";
  const colCross = "#B8821A"; // gold for cross-links

  // Node data: same 9 knowledge elements
  const labels = [
    "Fakt A", "Fakt B", "Fakt C",
    "Regel 1", "Regel 2", "Regel 3",
    "Def. X", "Def. Y", "Def. Z"
  ];
  const clusters = [0, 0, 0, 1, 1, 1, 2, 2, 2];

  // Novice positions: scattered across the canvas
  const novicePos = [
    [0.12, 0.22], [0.38, 0.12], [0.65, 0.20],
    [0.18, 0.50], [0.45, 0.48], [0.72, 0.55],
    [0.08, 0.80], [0.42, 0.82], [0.70, 0.78]
  ];

  // Expert positions: organized in 3 clusters
  const expertPos = [
    [0.15, 0.22], [0.30, 0.22], [0.225, 0.40],  // cluster 0 (top-left)
    [0.60, 0.22], [0.75, 0.22], [0.675, 0.40],  // cluster 1 (top-right)
    [0.33, 0.72], [0.48, 0.72], [0.405, 0.88]   // cluster 2 (bottom-center)
  ];

  // Intra-cluster edges (indices)
  const intraEdges = [
    [0, 1], [1, 2], [0, 2],
    [3, 4], [4, 5], [3, 5],
    [6, 7], [7, 8], [6, 8]
  ];

  // Cross-cluster edges
  const crossEdges = [
    [1, 3], [2, 6], [5, 7]
  ];

  // Cluster background rects (in normalized coords)
  const clusterBoxes = [
    { x: 0.08, y: 0.12, w: 0.30, h: 0.38, label: "Schema 1" },
    { x: 0.53, y: 0.12, w: 0.30, h: 0.38, label: "Schema 2" },
    { x: 0.26, y: 0.62, w: 0.30, h: 0.36, label: "Schema 3" }
  ];

  // Margins
  const mx = 40, my = 30;
  const cw = w - 2 * mx;
  const ch = h - 2 * my;

  const toX = (nx) => mx + nx * cw;
  const toY = (ny) => my + ny * ch;

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

  // Cluster backgrounds (hidden initially)
  const clusterGs = svg.selectAll("g.cluster-bg")
    .data(clusterBoxes)
    .join("g")
    .attr("class", "cluster-bg");

  clusterGs.append("rect")
    .attr("x", d => toX(d.x))
    .attr("y", d => toY(d.y))
    .attr("width", d => d.w * cw)
    .attr("height", d => d.h * ch)
    .attr("rx", 4)
    .attr("fill", colPos)
    .attr("fill-opacity", 0)
    .attr("stroke", colPos)
    .attr("stroke-opacity", 0)
    .attr("stroke-width", 1.5)
    .attr("stroke-dasharray", "6,4");

  clusterGs.append("text")
    .attr("x", d => toX(d.x + d.w / 2))
    .attr("y", d => toY(d.y) - 6)
    .attr("text-anchor", "middle")
    .style("font-size", "12px")
    .style("fill", colPos)
    .style("font-style", "italic")
    .style("opacity", 0)
    .text(d => d.label);

  // Intra-cluster edges
  const intraLines = svg.selectAll("line.intra")
    .data(intraEdges)
    .join("line")
    .attr("class", "intra")
    .attr("x1", d => toX(novicePos[d[0]][0]))
    .attr("y1", d => toY(novicePos[d[0]][1]))
    .attr("x2", d => toX(novicePos[d[1]][0]))
    .attr("y2", d => toY(novicePos[d[1]][1]))
    .attr("stroke", colPos)
    .attr("stroke-width", 2)
    .attr("stroke-opacity", 0);

  // Cross-cluster edges
  const crossLines = svg.selectAll("line.cross")
    .data(crossEdges)
    .join("line")
    .attr("class", "cross")
    .attr("x1", d => toX(novicePos[d[0]][0]))
    .attr("y1", d => toY(novicePos[d[0]][1]))
    .attr("x2", d => toX(novicePos[d[1]][0]))
    .attr("y2", d => toY(novicePos[d[1]][1]))
    .attr("stroke", colCross)
    .attr("stroke-width", 1.5)
    .attr("stroke-opacity", 0)
    .attr("stroke-dasharray", "4,3");

  // Nodes
  const nodeR = 28;
  const nodeGs = svg.selectAll("g.node")
    .data(labels.map((l, i) => ({ label: l, i })))
    .join("g")
    .attr("class", "node")
    .attr("transform", d => `translate(${toX(novicePos[d.i][0])},${toY(novicePos[d.i][1])})`);

  nodeGs.append("rect")
    .attr("x", -nodeR)
    .attr("y", -14)
    .attr("width", nodeR * 2)
    .attr("height", 28)
    .attr("rx", 4)
    .attr("fill", colNeg)
    .attr("fill-opacity", 0.8);

  nodeGs.append("text")
    .attr("text-anchor", "middle")
    .attr("dy", "0.35em")
    .style("font-size", "12px")
    .style("font-weight", "bold")
    .style("fill", "white")
    .text(d => d.label);

  // Subtitle
  const subtitle = svg.append("text")
    .attr("x", w / 2).attr("y", h - 8)
    .attr("text-anchor", "middle")
    .style("font-size", fs)
    .style("fill", colNeutral)
    .text("Isolierte Fakten \u2014 klicken zum Vernetzen");

  // Interaction state
  let expert = false;

  svg.on("click", () => {
    expert = !expert;
    const dur = 1000;
    const ease = d3.easeCubicInOut;

    // Move nodes
    nodeGs.transition().duration(dur).ease(ease)
      .attr("transform", d => {
        const pos = expert ? expertPos[d.i] : novicePos[d.i];
        return `translate(${toX(pos[0])},${toY(pos[1])})`;
      });

    // Change node color
    nodeGs.select("rect").transition().duration(dur).ease(ease)
      .attr("fill", expert ? colPos : colNeg);

    // Move and show/hide intra-edges
    intraLines.transition().duration(dur).ease(ease)
      .attr("x1", d => toX((expert ? expertPos : novicePos)[d[0]][0]))
      .attr("y1", d => toY((expert ? expertPos : novicePos)[d[0]][1]))
      .attr("x2", d => toX((expert ? expertPos : novicePos)[d[1]][0]))
      .attr("y2", d => toY((expert ? expertPos : novicePos)[d[1]][1]))
      .attr("stroke-opacity", expert ? 0.6 : 0);

    // Cross-edges
    crossLines.transition().duration(dur).ease(ease)
      .attr("x1", d => toX((expert ? expertPos : novicePos)[d[0]][0]))
      .attr("y1", d => toY((expert ? expertPos : novicePos)[d[0]][1]))
      .attr("x2", d => toX((expert ? expertPos : novicePos)[d[1]][0]))
      .attr("y2", d => toY((expert ? expertPos : novicePos)[d[1]][1]))
      .attr("stroke-opacity", expert ? 0.4 : 0);

    // Cluster backgrounds
    clusterGs.select("rect").transition().duration(dur).ease(ease)
      .attr("fill-opacity", expert ? 0.06 : 0)
      .attr("stroke-opacity", expert ? 0.5 : 0);

    clusterGs.select("text").transition().duration(dur).ease(ease)
      .style("opacity", expert ? 1 : 0);

    // Subtitle
    subtitle.transition().duration(300).style("opacity", 0)
      .transition().delay(expert ? 600 : 0).duration(300).style("opacity", 1)
      .text(expert
        ? "Vernetzte Schemata \u2014 klicken zum Aufl\u00f6sen"
        : "Isolierte Fakten \u2014 klicken zum Vernetzen");
  });

  return svg.node();
}

Anfängerwissen besteht häufiger aus isolierten Elementen. Expertenwissen ist vernetzt und in abrufbaren Einheiten organisiert.

Was organisierte Schemata ermöglichen

	Anfängerinnen und Anfänger	Expertinnen und Experten
Physik	„Aufgabe mit Rampe“	„Energieerhaltung“
Statistik	„Zwei Gruppen, also t-Test“	Wahl des Modells anhand der Datenstruktur
Transfer	Orientierung an Oberflächenmerkmalen	Erkennen der Tiefenstruktur

Das Lernziel bestimmt, welche Schemata und welche selbstständige Leistung aufgebaut werden sollen.

Kern: Transfer setzt voraus, dass Lernende die Tiefenstruktur erkennen. Ein produziertes Ergebnis zeigt noch nicht, ob diese Struktur aufgebaut wurde.

Jetzt bist du gefragt

Bearbeite Abschnitt 3: Vorwissen im Analysebogen.

Alle Informationen findest du dort.

Wenn das Arbeitsgedächtnis so begrenzt ist, wie können wir als Lehrende damit umgehen?

• T: CLT – Untersch. Arten von Last

Cognitive Load Theory

	Intrinsische Last	Extrinsische Last
Quelle	Elementinteraktivität relativ zum Vorwissen	vermeidbare Anforderungen der Darstellung oder Aufgabe
Steuerbarkeit	durch Sequenzierung und Vorwissensaufbau	durch Gestaltung reduzieren
Beispiel	statistische Interaktion verstehen	getrennte und schlecht auffindbare Informationen

Freie Kapazität ermöglicht lernrelevante Verarbeitung: Elemente auswählen, abrufen und zu Schemata verknüpfen (Sweller 2023).

Lernrelevante Anstrengung ermöglichen

Mehr Vorwissen und weniger unnötige Belastung bedeuten mehr Platz für lernrelevante Verarbeitung.

viewof vorwissen_controls = {
  const labels = ["wenig", "mittel", "viel"];
  const div = html`<div style="display:flex;align-items:center;font-size:22px;">
    <span style="width:300px;text-align:right;">Vorwissen:</span>
    <strong style="width:80px;text-align:center;margin:0 16px;">mittel</strong>
    <input type="range" min="1" max="3" step="1" value="2" style="width:340px;accent-color:#64748b;">
  </div>`;

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

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

  slider.oninput = () => {
    label.textContent = labels[+slider.value - 1];
    emit();
  };

  div.value = 2;
  return div;
}

viewof cl_controls = {
  const div = html`<div style="display:flex;align-items:center;font-size:22px;">
    <span style="width:300px;text-align:right;">Extrinsische Belastung:</span>
    <strong style="width:80px;text-align:center;margin:0 16px;">60%</strong>
    <input type="range" min="5" max="70" step="5" value="60" style="width:340px;accent-color:#D55E00;">
  </div>`;

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

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

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

  div.value = 60;
  return div;
}

constrain_ext = {
  const intr = 70 - vorwissen_controls * 20;
  const newMax = 100 - intr;
  const sliderDiv = viewof cl_controls;
  const slider = sliderDiv.querySelector("input[type=range]");
  const label = sliderDiv.querySelector("strong");
  slider.max = newMax;
  if (+slider.value > newMax) {
    slider.value = newMax;
    label.textContent = newMax + "%";
    sliderDiv.value = newMax;
    sliderDiv.dispatchEvent(new Event("input", { bubbles: true }));
  }
  return newMax;
}

cognitive_load_chart = {
  const w = 950;
  const h = 380;

  const intrinsic = 70 - vorwissen_controls * 20;
  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: 22})
    );
  }

  return Plot.plot({
    width: w,
    height: h,
    marginLeft: 80,
    marginBottom: 40,
    marginTop: 40,
    style: {fontSize: "24px", 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
  });
}

Modifiziert nach KI in der Lehre: Impuls

100% ist volle Belastung des Arbeitsgedächtnisses.

Szenario 1: Wenig Vorwissen. Variiere extrinsische Belastung.

Szenario 2: Mehr Vorwissen. Varriere extrinsische Belastung.

Ich kann auch weniger als 100% geben.

T: KI kann:

• vorwissen anpassen
• extrinsische Belastung reduzieren

Ein hilfreicher Begriff…

Jetzt bist du gefragt

Bearbeite Abschnitte 4: Lernrelevante kognitive Aktivitäten und 5: Kognitive Anforderungen und mögliche Schwierigkeiten im Analysebogen.

Alle Informationen findest du dort.

Bibliographie

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.