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.
Build my 6.1020 study planWhat 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.
- 5
Build the habits with Fennie
Upload the 6.1020 schedule — or the public readings if you're self-studying — and Fennie's Daily Plan paces readings, exercises, and pset stages so the discipline builds daily, with spec-and-testing quizzes generated from the actual course materials. Free to start.
Start my 6.1020 plan free
How Fennie helps with 6.1020
Fennie's Daily Plans pace 6.1020's readings and exercises daily — the spec-first, test-first habits only form through repetition. Chat through why an abstraction leaks or what a rep invariant should say, and quiz yourself on the design principles the graders are actually reading your code for.
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?
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.
Pass 6.1020 with a plan, not a cram
Upload your 6.1020 materials and Fennie generates a Daily Plan paced to your deadline — plus chat, flashcards, and quizzes built from the actual course content.
Get started freeMore 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 — sorting, hashing, trees, graph algorithms, shortest paths, and dynamic programming — emphasizing 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.