MIT 6.031

Why 6.031?

6.031 Software Construction is MIT's course on building correct, understandable, and evolvable software. I followed the 2021 (SP21) and 2022 (SP22) offerings to ground my programming in static checking, types, and the "big three" properties of good software. This Deep Dive summarizes what I took from the first two readings: Static Checking (SP21) and Basic TypeScript (SP22).

我系统学习了 MIT 6.031 的 2021 与 2022 版本，重点放在静态检查与 TypeScript 基础上，作为写好软件的第一块基石。

The Big Three Properties of Good Software

The course is built around three goals every program should aim for:

Static checking is the first major tool the course uses to make code safe from bugs.

Static Checking (SP21 — Reading 1)

Reading 1: Static Checking introduces types and the difference between static, dynamic, and no checking.

Types

A type is a set of values plus the operations that can be performed on them. In statically-typed languages (e.g. Java, TypeScript), variable types are known at compile time, so the compiler can catch many errors before the program runs—such as "5" * "6" (multiplying two strings).

Three Kinds of Checking

• Static checking: Bugs found before the program runs (wrong types, wrong number of arguments, misspelled names, syntax errors).
• Dynamic checking: Bugs found when the code runs (null reference, index out of range, divide-by-zero when the divisor is only sometimes zero).
• No checking: The language doesn’t help; you get wrong answers or undefined behavior.

Catching bugs statically is better than dynamically, and dynamically is better than not at all. Static typing prevents a large class of bugs: applying an operation to the wrong types of arguments.

The reading also warns about primitive types not being true numbers: integer division truncation, integer overflow, and floating-point special values (NaN, Infinity) that can hide errors.

Basic TypeScript (SP22 — Reading 2)

Reading 2: Basic TypeScript moves from Python to TypeScript and introduces snapshot diagrams, variable declarations, and mutability.

Variable declarations

TypeScript uses let for reassignable variables and const for unreassignable references. Types can be annotated explicitly, e.g. let n: number = 1; and const s: string = "hello";. Snapshot diagrams represent runtime state: the stack (methods and local variables) and the heap (objects). Double borders denote immutable values; double arrows denote unreassignable references.

Mutating values vs. reassigning variables

• Reassignment: Changing where a variable’s arrow points (e.g. s = s + "b").
• Mutation: Changing the contents of a mutable object (e.g. arr.push("b")).

Strings are immutable; arrays are mutable. const only makes the reference unreassignable—you can still have const arr: Array<string> = ["a"] and then arr.push("b"). The distinction between mutability and reassignability is central to writing code that stays safe from bugs.

Arrays, Maps, and Sets

TypeScript’s Array is like Python’s list; Map is like a dictionary; Set is an unordered collection of unique values. The reading maps common operations (e.g. lst.length, lst.push(e), lst.includes(e)) to their Python equivalents, which helps when transitioning from Python to TypeScript.

Takeaways

• Good software is safe from bugs, easy to understand, and ready for change.
• Static typing and static checking catch many errors at compile time; prefer them when building larger systems.
• Use snapshot diagrams to reason about references, mutability, and immutability.
• Understand the difference between reassigning a variable and mutating a value—and when to use const vs let.

References

• 6.031 SP21 — Reading 1: Static Checking
• 6.031 SP22 — Reading 2: Basic TypeScript (Variable declarations)
• 6.031 Software Construction (SP22) — Course site