Traditional Teaching and Learning, and Alternatives

[Feyerabend]

The start of this book/repository was that I wanted to write a book on "programming"
without resorting to a specific language. I've done that. I wanted it to be more general.
But still very practical in some respects, not leaning too much towards computer science,
but still towards abstractions such as they are to be found in e.g., theories of information,
or Hoare Logic.

I also wanted it to be oriented towards the more interesting (from my view) project-based
learning/teaching. The uniformity of lecture-centred teaching, the diversity of learner
needs, and the comparative logic built into traditional assessment, I found a bit unsettling.
I wanted it to be more oriented towards the pedagogical strengths of project-based learning
rather than defending the standard model.

So the goal became two fold: a book/repo on code/computing etc., and an example of another
way of learning/teaching than the regular.

We will get back to this: it was simply to introducing LLMs. But why stop at this? There are
surely many other alternatives out there ... suggestions?

Teaching Variations and the Reality of Diverse Learning Needs

The foundational problem in education stems from the mismatch between administrative
convenience and pedagogical reality. Lecture-centred models typically assume homogeneity:
that all learners require the same canonical body of knowledge at the same uniform pace,
and that performance should be measured through comparative assessment across a cohort.

This assumption rarely holds true. In mixed groups, particularly common in fields like
computer science and engineering, student backgrounds, goals, and prior knowledge vary
wildly. Once this assumption of uniformity is dropped, the entire model introduces structural
problems:

1. The Problems of Uniform Instruction

Teaching a shared framework efficiently has logistical appeal—it is easy to timetable,
highly predictable, and efficient for the instructor as one explanation reaches many.
However, from the learner's perspective, this uniformity often leads to inefficiency
and failure:

• Misalignment and Knowledge Waste: If only a subset of students will use a specific
  chunk of content, delivering that chunk to everyone via lectures is a blunt instrument.
  It favours curriculum symmetry over learner relevance, wasting valuable time on
  material peripheral to many student goals.
• Pacing Conflicts: A single tempo guarantees that some students will be bored, while
  others will fall behind as abstractions accumulate too quickly. This lag accumulates
  into a "slip and cannot catch up" dynamic, because the medium does not permit
  divergence or repair.
• Structural Disadvantage: When assessment is norm-based or competitive, students
  who fall behind early due to differing backgrounds or slower paces are punished
  structurally, often remaining statistically disadvantaged throughout the course.
  This comparative grading amplifies harm.
• Fragile Understanding: Learning driven purely by lectures can lead to brittle
  knowledge, where the ability to pass assessments does yet not translate into the
  capability to use the material meaningfully.

2. The Differentiated Approach of Project-Based Learning (PBL)

Project-based and inquiry-driven models handle heterogeneity by presuming variation
in pace and goals. Students acquire knowledge in the context of authentic goals, rather
than a predefined sequence. This provides significant advantages:

• Learner Differentiation and Relevance: Students can select project problems or
  angles that match their interests and future needs. Stronger students explore deeper
  paths while weaker students engage with simpler constructs, promoting personal relevance
  and reducing the "why are we all learning this?" complaint.
• Reduced Catch-Up Risk: Falling behind often means adjusting the project scope, not
  losing the entire conceptual thread. This allows students to recover by focusing on
  later components or redefining their goals, maintaining dignity and participation.
• Criterion-Based Assessment: PBL lends itself to competence-based evaluation (e.g.,
  "Does the analysis stand up?"). This focuses on mastery and understanding rather than
  comparing individuals against each other.

However, moving away from uniformity introduces new challenges:

• Risk of Uneven Foundations: If students follow divergent paths, they may miss essential
  fundamentals entirely, creating non-uniform knowledge distribution. This risk requires
  careful scaffolding to ensure students do not avoid difficult areas entirely.
• Assessment Complexity and Staff Workload: The high variability in project scope and
  ambition complicates evaluation, requiring instructors to design clear rubrics and
  dedicate more supervision to support many different paths.

3. Hybrid and Differentiated Solutions

Since neither pure lecture (high institutional efficiency, low learner efficiency) nor
pure PBL (high learner efficiency, lower institutional efficiency) is a perfect solution,
most effective educational environments require a blend—a choice between different degrees
of structure and autonomy.

Hybrid models are designed to preserve a shared foundation while supporting personalized depth:

• Lecture for Foundations, Project for Depth (Model A): Use short, focused lectures
  or "mini-lectures" for the core theory everyone truly needs (the common floor). Shift
  to projects for personalisation, creativity, and application (the personalised ceiling).
• Flipped Curriculum (Model B): Students acquire theoretical basics through guided reading
  or micro-lectures outside class, making content available to revisit. Class time is
  dedicated to problem-solving, application, and divergence.
• Modular Competency Tracks (Model C): Content is divided into discrete skill modules.
  Students engage with shared foundations but choose modules relevant to their aims, with
  projects serving as integrative assessments across chosen modules.
• Project-First, Lecture-On-Demand (Model D): Begin with an authentic problem, introducing
  short, precise explanations only when the project demands conceptual clarification, strongly
  aligning learning with actual use.
• Mastery/Studio Pacing: The content is delivered in small chunks, allowing students to
  pause, revisit, or accelerate at different speeds, often embedded inside a lab or studio
  environment where instructors circulate and provide on-demand explanations tailored to
  individual need.

The core structural question remains: What should everyone learn? If the aim is capability,
adaptability, and learner relevance for a mixed-ability group, structured hybrids that combine
shared fundamentals with flexible depth are usually the best solution.

[Feyerabend]

So what happends if we introduce LLMs?

LLMs and the Shift in Educational Dynamics

The introduction of LLMs accelerates the transition from uniformity (Lecture-Based) to hyper-differentiation (Project/Hybrid-Based) by providing the scale and flexibility that human instructors often lack.

1. The Core Changes (What and Why)

Change	How It Changes (LLM Function)	Why It Changes (Impact on Pedagogy)
End of Uniform Pacing	Adaptive Tutoring: LLMs can provide real-time explanations, drill-downs, and remediation tailored to a student's exact knowledge gaps.	Directly addresses the "slip and cannot catch up" dynamic by offering Mastery Pacing at scale. Students no longer wait for the instructor or the next class; help is instant.
Shift in Content Focus	Content Curation and Generation: LLMs can generate infinite practice problems, summarize complex texts, or create introductory materials on demand.	Frees class time from transmitting basic information. It solidifies the move toward "Flipped Curriculum" or "Project-First" models, reserving human instructor time for complex discussion and evaluation.
Personalized Relevance	Project Scaffolding and Coaching: LLMs can help students narrow project scope, find relevant resources, and debug code or logic within a differentiated project.	Drastically improves learner differentiation. Students can pursue highly niche interests within a project, and the LLM helps manage the technical complexity of that path.
Redefining Assessment	Automated Feedback and Competency Checks: LLMs can grade process-based work, provide deep, specific feedback on drafts, or design criterion-based quizzes for niche module content.	Supports the move to Criterion-Based Assessment by making complex, varied project evaluation feasible and scalable.

2. Impact on Teaching Models (How)

A. Lecture-Centred Teaching

LLMs essentially make the weaknesses of pure lectures unbearable, accelerating their decline for core content delivery.

Change	Mechanism
Reduced Time-on-Task	Students use LLMs to summarise lectures they skipped or to get a better explanation than the one given. The lecture's value for transmitting core content diminishes significantly.
Foundation Acquisition Moves Out-of-Class	LLMs replace the lecture for foundation acquisition. Students use them as personalized "micro-lecturers" or "study guides" for the necessary core material.
Shift to Interactive Seminar	The lecture time that remains must shift entirely towards Model A (Lecture for Foundations, Project for Depth), focusing only on the most difficult, abstract, or debate-worthy topics that require human-led discussion.

B. Project-Based Learning (PBL)

LLMs solve many of the logistical and scaffolding challenges that were previously the disadvantages of PBL, making it much more robust.

Change	Mechanism
Mitigating Domain Avoidance	If a student avoids a difficult concept (a PBL disadvantage), the LLM can provide targeted, on-demand tutorials and practice specific to that concept, acting as the necessary scaffolding to fill the gap.
Handling Assessment Complexity	The instructor uses the LLM to help refine assessment rubrics, generate tailored project prompts, and even draft initial feedback on project milestones, reducing the previously high staff workload.
Managing Non-Uniform Knowledge	The LLM can keep a log of the knowledge a student acquires during their divergent project path. This log can be used by the instructor to flag essential, missed fundamentals and assign a micro-module for remediation.

C. Hybrid / Differentiated Models

LLMs become the core engine that enables the flexibility required for advanced hybrid models to work at scale.

Change	Mechanism
Enabling Mastery Pacing at Scale	LLMs automate the creation and management of Modular Competency Tracks. Students can instantly access quizzes and tutorials for any module, progressing only when the LLM confirms mastery.
Powering On-Demand Learning	LLMs are the infrastructure for Model D (Project-First, Lecture-On-Demand). When a student needs clarification (the "lecture-on-demand" moment), the LLM delivers an instant, tailored explanation, making the human instructor the ultimate consultant.
Focusing the Human Instructor	The human role is elevated from content transmitter to designer, motivator, and evaluator of complex skills. Instructors focus on validating project quality, promoting critical thinking, and addressing the social and ethical aspects of the material.

3. New Challenges Introduced by LLMs

The changes are not without significant risk and new problems for the educational structure:

• Authenticity and Academic Integrity: LLMs can write essays, solve code, and derive complex solutions. Assessment must shift entirely away from recall or basic synthesis to focus on process, critique, oral defense, and application in human-validated environments.
• The Deeper Structural Question: LLMs force institutions to re-answer the question: "What is the unique value of the human teacher and the campus experience?" If knowledge can be acquired instantly and perfectly tailored, the curriculum must prioritise skills (critical thinking, collaboration, creativity) that the LLM cannot fully replicate.
• Equity and Access: Access to and training on powerful LLMs could create a new digital divide, potentially widening the gap between well-resourced students and those who lack the tools or the proficiency to use them effectively.

Any ideas on how to solve this?

[Feyerabend]

Looking at e.g. Why kids still need to learn to code in the age of AI we can see several things.
But if we just focus on one contrast: traditional and experimental--we might call them.

The position represented by the Raspberry Pi Foundation aligns closely with
the internal logic of formal education systems. Schools, by necessity, operate
through structure: they require content that can be defined in advance, ordered
into sequences, and evaluated in consistent ways. This creates an environment
in which knowledge must appear stable, transferable, and progressively accumulative.
Within that framework, the idea that coding constitutes a foundational literacy
makes immediate sense. It can be broken down into concepts such as abstraction,
decomposition, and debugging; it can be taught step by step; and it can be assessed.
The Raspberry Pi position therefore does not merely advocate for coding in education:
it reflects and reinforces assumptions that are already built into how education
functions. Even without it, similar arguments would likely emerge, because they
fit the institutional need for clarity, scalability, and comparability.

My position, by contrast, does not simply propose a different set of contents to
be inserted into that structure. It operates from a different vantage point altogether.
Instead of beginning with the question of what should be taught and how it should
be sequenced, it begins with the observation that actual engagement with computational
systems rarely conforms to the clean models that education presents. Systems behave
unpredictably, abstractions leak, and understanding is often partial and revised
through use. From this perspective, education is not primarily the design of a
pathway through predefined knowledge, but the creation of situations in which learners
encounter and work through these discrepancies. What is at stake is not the acquisition
of a stable method, but the capacity to navigate systems whose behaviour cannot
be fully captured in advance.

This difference places the two positions in an asymmetric relationship.
The Raspberry Pi stance is embedded within the visible structure of education;
it defines what counts as learning, how progress is measured, and how competence
is recognized. My stance, on the other hand, tends to appear at the edges of
that structure, or as a reflection upon it. It becomes visible when learners
confront the limits of what they have been taught, when systems fail to behave
as expected, or when the gap between formal knowledge and actual practice becomes
too large to ignore. It does not replace the institutional model so much as
expose its boundaries.

The distinction is therefore not simply between two opinions about coding,
but between two conceptions of education itself. One treats education as
the construction of reliable competence through structured progression.
The other treats it as an opening of possibilities through exposure to
complexity and variation. The first aligns with the requirements of institutions;
the second aligns with the realities of practice. As computational systems
become more opaque and less predictable, this distinction is likely to sharpen.
Institutions will continue to depend on structured, teachable models,
but the distance between those models and lived interaction with systems
will increase. In that widening gap, the kind of perspective I try to develope
does not function as an alternative curriculum within the system, but as a
necessary way of understanding what the system leaves out.

--

What is at stake, then, is not which position is correct, but what kind of
understanding we are willing to accept as sufficient. The structured model
can produce competence that is legible, testable, and widely distributable,
but it does so by stabilizing a world that is, in practice, unstable.
The experimental stance, on the other hand, does not offer the same clarity
or scalability, but it remains faithful to the conditions under which systems
are actually encountered and understood. As long as education is organised
around what can be defined in advance, it will continue to privilege the former.
Yet as long as computational systems resist full formalisation (as they
increasingly do) the latter will continue to reappear, not as an alternative
choice, but as a sort of necessity. The question is therefore not whether
we teach coding, but whether we are prepared to acknowledge that what can be
taught cleanly is only a fragment of what must ultimately be learned.

[musaabhasan]

The LLM angle strengthens the case for project-based learning, but it also changes what must be assessed. If the output artifact is the only evidence, assessment becomes weak because the artifact may hide too much of the learner's actual reasoning.

A better model is to assess the project as a bundle of evidence:

• the working artifact or program
• a design journal showing decisions, alternatives, and discarded paths
• short oral or written defense of the key abstractions
• version history that shows iteration rather than a single final submission
• tests or examples chosen by the learner, plus tests chosen by the instructor
• reflection on which assistance was used and how it changed the work

This keeps the educational value of LLMs without pretending that unaided production is still the only valid signal. The core learning question becomes: can the learner frame the problem, evaluate suggestions, explain tradeoffs, and repair failures?

That fits well with a language-independent computing book. The durable skill is not memorizing syntax; it is building reliable mental models of representation, state, logic, communication, and consequences.

[Feyerabend]

Thank you for this thoughtful response. I find it very valuable, especially since few
people engage seriously with what I think are highly consequential changes.

I agree that assessment must change. We cannot continue leaning on older educational
models as if nothing happened. This is also one of the most sensitive issues in education.
Many resist changing assessment because it challenges long-established assumptions about
learning and competence.

The model you outline is, I think, a very good starting point. In many practical settings
it may already be sufficient. At the same time, I would prefer to keep the exact components
open and context-dependent rather than fixed in advance.

What interests me most is the shift in what assessment is actually trying to measure.
Traditionally, the finished artifact has been treated as proof of understanding.
But that assumption was always weaker than we liked to admit. LLMs mainly expose this
more clearly.

The important question is no longer simply whether a student produced something, but
whether they can understand, explain, evaluate, and reshape it.

That is also why project-based learning becomes more important. Real projects force
students to deal with ambiguity, decomposition, debugging, tradeoffs, and changing
constraints. Those processes reveal understanding much better than isolated exercises.

I also think there is a risk that education responds defensively by creating increasingly
artificial exam conditions just to preserve old notions of authenticity. That may protect
measurement while losing relevance.

The deeper challenge is therefore not how to prevent AI use, but how to develop forms
of assessment that still reveal thinking, judgment, and conceptual understanding in an
environment where powerful generative tools are normal.

I suspect this also forces us to rethink what we mean by knowledge in programming
and computer science more broadly.

For a long time, education has been (naturally) strongly tied to production:
writing code from scratch, remembering syntax, reproducing known structures
under time pressure. Some of that stil matters, of course. But the center of
gravity is shifting. Increasingly, the difficult part is not producing code,
but knowing what should be built, why it should be built that way, and whether
the result actually makes sense. This is no longer any surprise.

In that sense, programming becomes less about isolated construction and more about
navigation through a space of possibilities. But that is a point that probably
will increase in the general awareness around education.

That changes the role of the student, but also the role of the teacher.
The teacher becomes less of a gatekeeper of information and more of a guide for
judgment, critique, modelling, and reflection. Not because knowledge disappears,
but because access to generated material becomes abundant while understanding
remains scarce.

And perhaps this is why the discussion becomes emotionally charged. Assessment
has never only been about learning. It is also tied to legitimacy, institutional
trust, selection, and professional identity. When AI destabilises older forms
of assessment, it also destabilises many implicit ideas about merit and competence.

But resisting this shift by trying to recreate pre-LLM conditions may ultimately
be self-defeating. Students already live in a world saturated with these systems.
Education cannot remain meaningful by pretending otherwise.

So the question may no longer be:
"Can the student produce this alone?"

Instead, it becomes something closer to:
"Can the student think meaningfully in this new environment?"