Staff Writer
Covers programming languages, compilers and type systems.
WebAssembly modules are portable but awkward to connect. The component model adds typed interfaces so modules written in different languages can talk to each other.
Ownership and borrowing are why Rust needs no garbage collector. Three rules, a few examples, and the mental model that makes the borrow checker click.
You don't have to type everything at once. A step-by-step strategy for introducing type checking to an existing project without stopping feature work.
Pattern matching has spread from functional languages into the mainstream. The syntax differs, but the idea — destructure and branch on shape — is the same.
async/await looks like sequential code but runs very differently. Understanding event loops and suspension points explains the performance — and the pitfalls.
Generics let you write code once for many types without giving up type safety. TypeScript, Go and Rust each approach them differently.
Data that never changes is easier to reason about, share and test. Persistent data structures make immutability practical without copying everything.
Garbage collection frees you from manual memory management, but it isn't free. A tour of the main algorithms and what they mean for latency.
Some languages throw errors up the stack; others return them as values. Each approach makes different mistakes easy or hard.
Asking for the length of a string has at least three correct answers. Understanding why prevents a family of text-handling bugs.
Floating point isn't broken — it's binary. Understanding what it can and can't represent tells you when to use it and when to reach for decimals or integers.
Every language implementation follows a recognizable pipeline. Knowing the stages makes error messages, tooling and performance easier to understand.
