Programming Languages

Knowing a language superficially is enough to land a junior role. Knowing it deeply -- its idioms, its sharp edges, the problems it was designed to solve and the ones it was not -- is what separates senior engineers from mid-level ones. This section is not a language tutorial. It assumes you can already write working code and focuses on the parts that take years to internalize.

Why Language Depth Matters

Every language encodes a set of opinions about how software should be built. Go says "simplicity and explicit error handling." Rust says "memory safety without garbage collection." TypeScript says "catch shape errors at compile time." Python says "readability and batteries included." Java says "enterprise reliability at scale."

When you understand why a language makes the choices it does, you stop fighting it. You write idiomatic code. You reach for the right abstractions. You debug faster because you understand what the runtime is doing, not just what your code says.

The polyglot engineer -- someone comfortable in three or four languages across different paradigms -- has a compounding advantage:

• Better design instincts. Patterns from one language inform solutions in another. Go's interface composition improves how you think about TypeScript abstractions. Rust's ownership model changes how you reason about lifetimes everywhere.
• Faster onboarding. A new language is easy when you already know the underlying concepts. The syntax is a skin; the semantics are what matter.
• Broader career options. The NZ market is small enough that being locked into one language limits your opportunities significantly.

NZ Market Demand by Language

The New Zealand tech market has clear patterns:

TypeScript is the lingua franca. Java dominates enterprise. Go is the language of choice for new backend services at companies that care about performance and simplicity. Python is everywhere data lives. Rust is the one interviewers ask about to gauge your curiosity.

If you are building a career in NZ, TypeScript + one backend language (Go or Java) + Python for scripting covers the vast majority of opportunities. Rust is a differentiator, not a requirement -- but it signals engineering depth.

How This Section Is Organized

Each article covers a single language (or closely related pair) and focuses on:

1. Philosophy and design decisions -- what the language optimizes for and why
2. Idioms and patterns -- the way experienced practitioners write the language, not just correct code
3. Sharp edges -- the parts that trip up even experienced engineers
4. Practical code -- working examples that demonstrate real patterns, not toy exercises
5. Ecosystem essentials -- the libraries, tools, and conventions you need to be productive
6. Career context -- where the language fits in the NZ and global market

The articles:

• Go -- simplicity as a feature, goroutines, error handling, interfaces, and the standard library
• TypeScript Advanced -- the type system as a programming language, generics, utility types, and advanced patterns
• Python -- backend frameworks, decorators, async, type hints, and the data engineering bridge
• Java & Kotlin -- modern Java, Spring Boot, JVM internals, Kotlin's advantages, and enterprise NZ
• Rust -- ownership, lifetimes, traits, fearless concurrency, and when Rust is the right choice

Each article is written for someone who has at least read the language's tutorial. The goal is to accelerate the journey from "I can write it" to "I understand it."