Can You Explain It? – Project Fair as Exam Format
This is a translation. View original (Deutsch)
How do you test programming when the code no longer has to be written by the student?
This question has been on my mind since November 2022, when ChatGPT started producing passable Python code. The standard answer is often: closed-book exam. Programming on paper. That answer feels outdated.
We’re training people who will probably work with AI tools later. Why should they pretend these tools don’t exist during exams?
One approach I find interesting: Stop asking “Did you write all of this yourself?” and ask instead “Can you explain it?” Authorship of the code is no longer the deciding criterion. Understanding is.
inf.zone – All course materials for “Introduction to Computer Science”
BaKuLe project – our StIL-funded project at the University of Bamberg
On February 2, as part of our BaKuLe project at the University of Bamberg, we tried out this approach systematically for the first time – with 53 projects and 70 students from my “Introduction to Computer Science” course. The format is a public project fair, inspired by Harvard’s CS50 Fair.
The idea: Students develop their own software project throughout the semester. They choose the topic, technology, and scope themselves. At the fair, they present their project at a standing table as a live demo and answer questions.
No slide presentations. What’s required: Speaking freely, handling your own laptop competently, navigating through your code quickly. Confident demeanor.
Grading criteria
We rate each dimension on a scale from 0 to 3. The sum is doubled – resulting in 0 to 18 bonus points that improve the grade if the final written exam is passed.
Demo and presentation. Does the prototype run? Does it look good? Is it easy to use? Can listeners understand what problem is being solved? We ask: “What happens if I enter something unexpected here?”
Code orientation. Can the person navigate their own code? We ask: “Show me where this feature is in the code.” – “If you wanted to change X – where would you look?”
Independent work and motivation. Are there original ideas beyond tutorials? We ask: “What was a particularly difficult part?” – “What would you build if you had three more months?”
We spend about 15 to 20 minutes per project. Usually you can tell within the first few minutes whether the person actually knows what’s going on.
AI-generated code is explicitly allowed. Using it and understanding it demonstrates competence. Using it without understanding it means fewer or no bonus points.
Three days before the fair, we organize a voluntary hackathon that runs late into the night. Pizza and drinks, dim lighting, a room full of people working on their projects. About half of the later fair participants were there this time.
You make new acquaintances casually and can look over others’ shoulders. You see that others are struggling too. Our tutors helped with implementation.
I walked around in a hoodie, answered questions, broke down barriers. Over the course of the evening, I talked with many students. They proudly showed me their half-finished prototypes – or shyly asked if I could make them a cappuccino on our espresso machine.
After the fair, it’s not over yet. Code and a screencast video are due about two weeks later, enough time for final polish. The submission is worth 2 of the 20 possible bonus points. The fair: 18 points.
An important signal: We grade what someone can do, not what someone uploads.
What we observed
53 projects, 50 percent more than last year. About 30 percent of the roughly 260 students registered for the exam participated.
The other 70 percent decided against it – time commitment, reluctance to present publicly, or because 20 bonus points weren’t enough incentive.
A finding from last year: Students who had participated in the fair almost all passed the exam on the first attempt. Of the others, almost none did. Correlation, not causation. We can’t separate how much of that is prior knowledge, how much is motivation, how much is actual learning effect.
Does this format widen the gap between strong and weak students even further? Hard to say – and hard to measure.
It's not an oral exam, it's small talk – and that's exactly what makes the difference.
The atmosphere during the fair was noticeably more relaxed than oral exams. Some students maybe took it too casually. Others were nervous, but nobody seemed paralyzed. Only four of the 53 registered projects didn’t show up.
We were pleased that a few alumni from last year’s cohort stopped by to see what the next class had built.
Grading consistency
For grading, we split the 53 projects into two rounds of 75 minutes each. Nine people did the grading. But did everyone apply the same standards?
Probably yes, with caveats.
The overall average was 6.6 out of 9 possible points. Individual grader averages ranged from 5.3 to 8.4 – a spread of 3.1 points. The most lenient grader gave three points more on average than the strictest.
That sounds like a lot. But: each grader saw different projects. Whoever happened to be assigned stronger projects appears more lenient in the statistics.
For bonus points, these subjective variations seem acceptable to us. Nobody loses anything; everyone can only gain.
What would be the alternative? A single person grading all projects would have taken more than 15 hours. Fatigue and order effects would probably have caused distortions there too.
If this were about determining the final module grade, a different approach would be needed – for instance, having each project graded by two people. That would be considerably more effort though.
Limitations and outlook
The fair is a demanding exam format. Room setup: lighting, music, standing tables, running extension cords across the hall. Briefing graders, creating schedules, informing students about procedures.
With nine people, we needed about 20 grader-hours total for 53 projects. Our upper limit would be 30 projects per round – we don’t have more standing tables.
The format reaches the already motivated. The 70 percent who didn’t participate, those who according to last year’s data have lower chances of passing the exam, we don’t reach with this. Whether the format would also work if mandatory, we don’t know yet.
If you can explain your code, you've learned something – regardless of whether the first or last version was generated by Claude Code.
The project fair doesn’t replace written exams. It complements them. It tests skills that remain invisible in traditional formats: Can someone talk about code? Does the person understand architectural decisions? Do they have their own ideas?
In the summer semester, we’ll continue our search for modern exam formats: Selected projects can be developed into exhibits for our faculty’s WIAI25 anniversary for 6 ECTS credits – then the live presentation at the booth will be mandatory and a major part of the final grade.