MIT 6.1020: Software Construction
6.1020, formerly 6.031 (whose public course readings are a renowned free resource), teaches writing software that's safe from bugs, easy to understand, and ready for change: specifications, testing, abstract data types, and concurrency. It's MIT's software engineering foundation, taught in recent terms in TypeScript after years in Java.
Fennie is independent and not affiliated with MIT. This is an unofficial study guide.
What makes it hard
The course grades how you write code, not whether it runs. Specs, invariants, and test-first discipline are the actual curriculum, and strong programmers used to just making things work find their habits suddenly insufficient. Concurrency at the end is the conceptual spike: race conditions resist the debugging instincts everything else built.
What you'll cover
- • Specifications and contracts
- • Test-first programming
- • Abstract data types and invariants
- • Immutability and equality
- • Recursive data types
- • Concurrency and thread safety
The 6.1020 study guide
How to study for MIT 6.1020, step by step.
- 1
Do the readings actively, exercises included
The course readings, public on the web and famously good, embed exercises that build the judgment the psets grade. Reading without doing them is how strong programmers end up surprised by their grades.
- 2
Write the spec before the body, every time
Preconditions, postconditions, and what's left unsaid: the spec-first habit is the course's core deliverable. Practice it on small functions until it stops feeling like ceremony.
- 3
Let the tests drive, genuinely
Write the test suite from the spec before implementing. It feels slower for a week and then permanently faster, because the tests catch the misunderstandings while they're still cheap.
- 4
Slow way down for concurrency
Race conditions don't yield to normal debugging; they yield to reasoning about interleavings. Work the concurrency readings' examples by hand, tracing what each thread can observe, before touching the pset.
Today
Today's 6.1020 plan
What a Fennie Daily Plan looks like for 6.1020. Yours is built from your own syllabus and adapts every day to your deadlines and progress.
First plan free, no card required. Fennie is independent and unaffiliated with your school.
FAQ
Is 6.1020 the same as 6.031?
Yes. 6.031 became 6.1020 in the 2022 renumbering. The famous public course readings remain the heart of the course; recent versions use TypeScript where older ones used Java.
Is 6.1020 hard?
The hours are steady and the adjustment is philosophical: code is graded on safety, clarity, and changeability, not just behavior. Concurrency is the one unit that's hard in the traditional sense.
Can I self-study 6.031/6.1020?
Yes, mostly. The full course readings with embedded exercises are publicly available and self-study-friendly. You lose the autograded psets and code review, so pair the readings with a real project you hold to the course's standards.
More MIT courses
6.100A: Introduction to Computer Science Programming in Python
6.100A, formerly 6.0001 (the number most search results still use), is MIT's half-semester introduction to programming in Python for students with little or no experience. The 6.0001 lectures on OpenCourseWare are among the most popular free programming courses anywhere.
6.006: Introduction to Algorithms
6.006 is MIT's core algorithms class, covering sorting, hashing, trees, graph algorithms, shortest paths, and dynamic programming, with emphasis on both rigorous analysis and Python implementation. Its OpenCourseWare lectures are a global standard for learning algorithms and prepping technical interviews.
6.046J: Design and Analysis of Algorithms
6.046J, renumbered 6.1220 in MIT's current catalog but still searched overwhelmingly by its old number, is the advanced algorithms course following 6.006: divide and conquer, randomized algorithms, amortization, network flow, approximation, and complexity. The OCW lectures are a staple for advanced self-study.
6.042J: Mathematics for Computer Science
6.042J, now numbered 6.1200J, is MIT's discrete math course for CS: proofs, induction, number theory, graph theory, counting, and discrete probability. Its OCW versions, with full lecture videos and the famous free textbook, make it one of the most-used discrete math resources in the world.