Programming languages

Static and dynamic answer when types are checked. Rust is statically typed, so the compiler must know the type of every variable before the program runs, and C# says every variable “has a type known at compile time.” Python checks as it goes: a name can hold an int now and a str later, and annotations are optional, because “the Python runtime does not enforce function and variable type annotations.” Gradual typing sits in between: Elixir is adding set-theoretic types to its compiler, with a dynamic() type for values checked at run time.

Inference removes most of the cost of static types. Haskell, F#, Scala and Rust work out the types of local values from how they’re used, so the code reads almost like a dynamic language while the compiler still checks it.

Strong and weak have no agreed definition. They usually mean how far the language converts values between types on its own. JavaScript’s + converts the other operand to a string if either side is a string, so "1" + 1 is "11". Python refuses the same expression with a TypeError, and Java’s specification calls the language “strongly and statically typed.”

In C, memory from malloc stays allocated until the program passes it to free; forgetting leaks it, and freeing the same block twice is undefined behaviour. Zig keeps that model on purpose: the language “performs no memory management on behalf of the programmer,” and every function that allocates takes an allocator as a parameter, which is why Zig needs no runtime and suits kernels and embedded devices. C++ is manual too, but destructors release resources when an object goes out of scope (RAII), which Stroustrup describes as memory management that is “safe and implicit without a garbage collector.”

Most languages hand memory to a garbage collector instead. Java’s specification puts it bluntly: objects “are never explicitly deallocated.” CPython frees most objects as soon as their reference count drops to zero and runs a cycle collector for the rest. BEAM gives every process its own small heap and collects each one separately.

Rust takes a third route. Every value has one owner, the compiler checks the ownership rules, and the value is freed when its owner goes out of scope. There is no collector and, in the Rust book’s words, none of these checks slow the program down while it runs; the cost is learning the rules.

Paradigm is about how a program is organised. Object-oriented languages bundle data with the methods that act on it; functional languages build programs from functions and immutable values. Few languages are pure examples: C# describes itself as object-oriented with features from other paradigms, Scala and F# mix both, and Clojure calls itself a functional language with a dynamic emphasis.

Concurrency is often where languages differ most. Go multiplexes cheap goroutines onto OS threads; Erlang and Elixir run millions of isolated processes that share nothing and exchange copied messages; Java 21 added virtual threads; C# offers async/await over Tasks. The models are compared in Synchronous and asynchronous execution.