In 2006 Dehnadi and Bornat published a paper with a memorable title: The Camel Has Two Humps. They claimed to have found a test that could predict, before any lesson, who would manage to learn programming and who wouldn’t. The idea spread quickly under the name “geek gene”: either you have it, or give up.
In 2014 Richard Bornat published a retraction, explaining that the result had not been replicated and that the original paper should not have been read the way it was. The retraction got a fraction of the original’s reach, and the myth outlived the evidence behind it.
That is the necessary premise for talking about learning to code as an adult, because almost all the remaining research points the same way.
The data on grade distributions
If a binary aptitude existed, grades in introductory computer science courses should distribute across two peaks: those who get it and those who don’t. That is a testable claim, and someone tested it.
Patitsas, Berlin, Craig and Easterbrook (ICER, 2016) analysed 778 grade distributions from computer science courses at a research university. The result: only 5.8% were multimodal. The vast majority had the normal distribution you find in any other subject.
The study has a second, more embarrassing part: when the same computer science instructors were shown an ambiguous distribution, they classified it as bimodal more often if it was labelled as a computer science course. The belief produced the perception.
There is no “two-hump curve” for programmers. There is a subject with a high dropout rate for pedagogical reasons, read through a self-confirming belief.
How people actually learn: three robust findings
The good news is that learning to program doesn’t need its own theory. What holds for learning complex skills in general holds here, and that literature is solid.
1. Retrieval beats rereading. Roediger and Karpicke (Psychological Science, 2006) showed that testing memory produces markedly better long-term retention than rereading the same material, even when students believe the opposite. Applied to code: closing the tutorial and rewriting the function from memory beats reading it three times.
2. Spacing beats cramming. Cepeda and colleagues (Psychological Bulletin, 2006) meta-analysed over 250 studies on the spacing effect: intervals distributed over time produce better retention than massed sessions, for the same total time. One hour a day for six days beats six hours on Saturday.
3. Worked examples beat free discovery, at the start. Sweller and Cooper (Cognition and Instruction, 1985) documented the worked example effect: for complete beginners, studying solved solutions and then tackling analogous problems is more efficient than attacking the problems directly. Kirschner, Sweller and Clark (Educational Psychologist, 2006) extended the argument: minimally guided instruction is particularly ineffective for novices, because cognitive load consumes the resources learning would need.
The third point contradicts the most common online advice, “learn by building projects”, and needs qualifying: the advice is right, but not in the first phase. The effect reverses with experience.
Reading code before writing it
There is a specific strand of computing education research worth citing because it yields a rare, operational piece of advice.
Lister and colleagues (ITiCSE Working Group Report, 2004), in a multinational study of novice students, documented that many could not predict the output of short code fragments. Venables, Tan and Lister (ICER, 2009) went deeper into the relationship between tracing, explaining and writing code, finding that the ability to follow a program’s execution is a practical prerequisite for the ability to write one.
The operational consequence: if you can’t say what a loop prints before running it, writing more code doesn’t fix the problem. You need to trace.
| Phase | What works according to the research |
|---|---|
| Very first steps | Worked examples, manual code tracing |
| Consolidation | Active retrieval, spaced practice |
| Autonomy | Real projects, minimal guidance |
| Always | Fast feedback on specific errors |
AI changes the equation, but not how you think
Peng, Kalliamvakou, Cihon and Demirer (2023) ran a controlled experiment with 95 developers split between those using GitHub Copilot and those not, on implementing an HTTP server in JavaScript. The assisted group completed the task roughly 56% faster.
The number is striking, but read it for what it is: already competent developers, on a well-defined task. It is not a finding about learning.
For learners, the caveat from the whole cognitive-load literature applies: if the assistant produces the solution, active retrieval never happens, and retrieval is precisely the mechanism that generates retention. The tool accelerates production and can slow learning, which are two different goals.
A path for the first few months
1. Pick a language and stop picking. Python or JavaScript are both fine to start. Time spent comparing them is time not spent on the first one, and the basic constructs transfer anyway.
2. Trace before you write. Take ten five-line code fragments, write on paper what they’ll print, then run them. It is the exercise Lister used to measure the problem, and it works as the remedy too.
3. Close the tutorial and rewrite. After each lesson, reproduce from memory what you just saw, without looking. You’ll get it wrong: that is exactly where retention forms.
4. One hour a day, not one weekend a month. It is the most replicated finding in the psychology of learning and the most ignored. We collected the method in learning a skill in 30 days.
5. Move to projects when the constructs are automatic, not before. The worked example effect reverses with experience: minimal guidance is excellent for people who already have the basics, counterproductive for those who don’t.
6. Use the assistant to explain, not to produce. “Why does this code throw an error” is a question that teaches. “Write me the function” is a question that delivers. How to frame requests is in how to use ChatGPT at work.
7. Check what the market asks for first. If the goal is employment, the language matters less than the role: the data on most in-demand jobs and the logic of certifications are the filter to apply before investing months.
My take: the “geek gene” is convenient for everyone
I think the “geek gene” outlived its own refutation because it is convenient for everyone: it justifies quitting for those who quit and explains success as talent for those who stay.
I think what makes the difference, more than intelligence, is tolerance for being stuck for twenty minutes without closing the editor. I suspect that is simply Sweller’s cognitive load seen from outside: someone who has automated the syntax has resources free for the problem, someone who hasn’t burns through them. It hasn’t been measured, so I label it for what it is: a hypothesis, not a finding.
Frequently asked questions
Am I too old to start? Nothing in the research cited here identifies an age limit. The study claiming a fixed aptitude was retracted by its author, and grade distributions in introductory courses are not bimodal.
Bootcamp or self-teaching? There are no robust independent experimental studies on bootcamps, and it’s worth saying so rather than pretending otherwise. What the research does support is structure: external deadlines and fast feedback improve completion, regardless of format.
How long does it really take? It depends on the goal, and the figures circulating have no experimental basis. The usable finding concerns distribution: for the same total hours, spreading them over time produces more retention than concentrating them.
Do I need maths first? For application programming, no. For specific areas such as graphics, cryptography and machine learning, yes, and that is a real prerequisite, not a cultural filter.
Will AI make coding skills useless? The available data measures production speed-ups by competent developers, not replacement. The part that stays human, across every study on the subject, is recognising when the output is wrong. And that requires being able to read code.
Sources
- S. Dehnadi, R. Bornat, The Camel Has Two Humps, working paper, 2006. Proposal for a test predicting programming aptitude.
- R. Bornat, Camels and Humps: A Retraction, 2014. The author’s retraction: the result was not replicated and does not support innate aptitude.
- E. Patitsas, J. Berlin, M. Craig, S. Easterbrook, Evidence That Computer Science Grades Are Not Bimodal, ICER, 2016. Analysis of 778 grade distributions; only 5.8% multimodal.
- H. L. Roediger, J. D. Karpicke, Test-Enhanced Learning: Taking Memory Tests Improves Long-Term Retention, Psychological Science, 2006. Superiority of active retrieval over rereading.
- N. J. Cepeda, H. Pashler, E. Vul, J. T. Wixted, D. Rohrer, Distributed Practice in Verbal Recall Tasks: A Review and Quantitative Synthesis, Psychological Bulletin, 2006. Meta-analysis of the spacing effect across over 250 studies.
- J. Sweller, G. A. Cooper, The Use of Worked Examples as a Substitute for Problem Solving in Learning Algebra, Cognition and Instruction, 1985. Worked example effect.
- P. A. Kirschner, J. Sweller, R. E. Clark, Why Minimal Guidance During Instruction Does Not Work, Educational Psychologist, 2006. Ineffectiveness of minimally guided instruction for novices.
- R. Lister et al., A Multi-National Study of Reading and Tracing Skills in Novice Programmers, ITiCSE Working Group Report, 2004. Novices’ difficulty predicting the output of simple code.
- A. Venables, G. Tan, R. Lister, A Closer Look at Tracing, Explaining and Code Writing Skills in the Novice Programmer, ICER, 2009. Relationship between tracing, explaining and writing code.
- S. Peng, E. Kalliamvakou, P. Cihon, M. Demirer, The Impact of AI on Developer Productivity: Evidence from GitHub Copilot, 2023. Experiment on 95 developers; roughly 56% faster completion with an assistant.



