Type hints, ownership and Rust: how much should the compiler check?

There is no single right amount of compiler checking. The people who build and use these languages disagree about where the line belongs, and the most practical reading is that checking is something you choose per project, not once for life.

Guido van Rossum, the creator of Python, kept type hints optional. Python has no declarations, which he sees as a real benefit to beginners because there is less bookkeeping to learn. Hints let you say that a variable is an integer or that a function returns a list of strings, and he calls them more than documentation. The key limit is "But that's not checked when you run the code." A separate static type checker reads the code without executing it and flags inconsistencies. He chose not to enforce the annotations because they are sometimes wrong and enforcement would break highly dynamic programs. He is no skeptic of static checking: he would recommend TypeScript over plain JavaScript.

Chris Lattner, who is building the Mojo language, criticizes that arrangement. Python's hints are ignored by the interpreter, read differently by competing tools and useless for performance. In Mojo, typing is still optional, but once you declare a type the compiler enforces it and uses it for speed. He adds ownership, so values are transferred instead of copied, which prevents bugs where one piece of code silently changes data another holds. He does not think untyped code is second-rate, and expects large teams to require types by house rule.

Jean-Baptiste Kempf and Kieran Kunhya, who maintain the video software VLC and FFmpeg, accept memory safety as a goal but will not trade away handwritten assembly, testing discipline or a working codebase to get it. Kunhya says Rust code in FFmpeg would have to meet the same bar as everything else: "It needs to be flawless." Kempf uses Rust for new projects and warns against rewrites. He notes that if you need inline assembly for speed, the surrounding language's safety guarantees no longer hold. In place of compiler guarantees they rely on a testing system that demands identical output across many platforms.

ThePrimeagen, who works in several languages, likes Rust's ownership and explicit mutability and still reaches for Go and Zig. He also adds asserts that crash the program when an impossible state occurs, and says they found bugs he would never have caught otherwise.

They agree that checking matters more as code and teams grow, that strictness should not be forced on beginners, and that you cannot ask the world to rewrite its code. They disagree on whether a declared type should be binding, on what compilers can deliver for speed, and on Rust. The sources offer few measurements of bugs prevented, and Mojo was unfinished when discussed.

What to do with it: start loose and tighten as the code grows. Run a static type checker in continuous integration for Python, and do not treat hints as guarantees. Prefer TypeScript to plain JavaScript. Learn one dynamic and one strict language. Use a strict language for new projects and be wary of rewrites. Hold new code to the existing test bar. Add asserts for states that should be impossible. Know where your safety model stops.