Why don't schools teach debugging, or, more fundamentally, fundamentals?
Universities and schools often graduate students who can syntax-check code but struggle with systematic debugging or even basic problem-solving, raising questions about whether curricula are teaching practical fundamentals. Commenters debate whether programming and debugging should be mandatory skills or reserved for motivated specialists, and whether omitting them constitutes gatekeeping that disadvantages less privileged students. Many attribute the gap to structural incentives—professors rewarded for research rather than teaching, CS programs focused on theory over software engineering, and limited time to remediate missing basics—while others note that debugging is a general scientific skill that could and should be taught more explicitly.
Role of Schools and Universities
- Many comments argue schools serve mixed purposes: education, workforce preparation, credentialing, and filtering.
- Universities are seen as hiring researchers, not teachers; incentives favor publications over pedagogy.
- Some say undergrad teaching should be led by trained educators, with researchers focusing more on advanced/graduate work.
- Others defend universities as places that provide resources; learning is primarily the student’s responsibility.
Can and Should Debugging Be Taught?
- Strong disagreement: some say debugging basics can be taught quickly and systematically (scientific method, hypothesis testing, narrowing search).
- Others view debugging as a craft learned best when students are stuck on their own code, not via whiteboard demos.
- Multiple people report courses that did explicitly teach GDB or similar tools; others say they had to learn all debugging on the job.
- Distinction made between “debugging as mindset/process” vs “using a debugger UI”; the article is mostly about the former.
Programming vs Computer Science vs Software Engineering
- Repeated theme: CS programs often emphasize theory (math, algorithms, compilers, architecture) and explicitly do not aim to teach programming as a vocational skill.
- Some defend this separation, comparing it to physics vs welding or architecture vs bricklaying.
- Others argue most students actually want software-engineering skills and are misled when “computer science” degrees don’t teach them.
Fundamentals and Prerequisites
- Debate over whether classes should backfill missing fundamentals (algebra, commas, basic debugging) vs rely on prerequisites and remedial tracks.
- Concern that slowing courses for unprepared students harms those who are ready; counter-argument is that failing to teach basics means institutions are failing students.
Learning, Ability, and Self-Study
- Many stress self-study, preparation before lectures, and practice as key differentiators between successful and struggling students.
- Disagreement over innate ability: some claim many simply cannot handle abstraction; others say poor teaching and lack of tailored explanations are the real issue.
Debugging as General Problem-Solving
- Several connect debugging to broader troubleshooting skills (lab sciences, IT support, plumbing, everyday life).
- Suggestion that systematic debugging is just applied science and should be taught as a general reasoning skill, not only in programming contexts.
Tools and Pedagogy
- Some advocate early, deep exposure to debuggers, unit tests, and version control; others warn over-reliance on interactive debuggers and prefer tests/print-debugging.
- Lab-style, small-group, or 1:1 settings are viewed as more effective for teaching debugging than large lectures.