LangIndex

Index

Concepts

Cross-language ideas grouped by type systems, memory, runtime, concurrency, paradigms, and tooling.

Type Systems concepts

Type Systems

How languages describe values, generic code, absence, inference, and type relationships.

7 pages

Reference page

Static vs Dynamic Typing

Static and dynamic typing describe when a language checks type rules: before a program runs, while it runs, or through a deliberately gradual mix of both.

Open page

Reference page

Strong vs Weak Typing

Strong and weak typing describe how readily a language lets operations cross type boundaries through implicit conversions, not whether type checks happen before or during execution.

Open page

Reference page

Type Inference

Type inference lets a compiler or checker determine types from expressions and context, reducing annotations while still preserving static feedback where the language supports it.

Open page

Reference page

Structural vs Nominal Typing

Structural typing checks whether a value has the required shape, while nominal typing checks relationships through declared names such as classes, interfaces, traits, protocols, or aliases.

Open page

Reference page

Generics and Parametric Polymorphism

Generics let one definition work over many types while preserving type information, but languages differ in constraints, variance, runtime representation, and code generation strategy.

Open page

Reference page

Null Safety

Null safety is the set of language, type-system, tooling, and library practices that make absence explicit instead of letting every reference silently be missing.

Open page

Memory concepts

Memory

Resource lifetime, allocation, reclamation, and safety models across native and managed runtimes.

7 pages

Reference page

Ownership

Ownership is a memory-management and resource-management model where rules about who controls a value, who may borrow it, and when it is cleaned up are enforced by the language or by project discipline.

Open page

Reference page

Garbage Collection

Garbage collection is automatic memory reclamation where a runtime or implementation identifies objects that can no longer be reached and makes their storage available again.

Open page

Reference page

Reference Counting

Reference counting tracks how many owners or strong references point at a value and reclaims the value when the count reaches zero.

Open page

Reference page

Manual Memory Management

Manual memory management makes allocation, deallocation, and ownership transfer explicit in program code, API contracts, or allocator parameters.

Open page

Reference page

Stack Vs Heap Allocation

Stack and heap allocation describe different storage strategies for values, with tradeoffs around lifetime, size, movement, sharing, and runtime management.

Open page

Reference page

Memory Safety

Memory safety is the property that code cannot perform invalid memory access such as use-after-free, double-free, out-of-bounds access, or dereferencing invalid pointers.

Open page

Runtime And Execution concepts

Runtime And Execution

Interpreters, bytecode, compilation targets, interop boundaries, ABIs, and standard libraries.

6 pages

Reference page

Interpreters, JIT, And AOT

Interpreters, just-in-time compilers, and ahead-of-time compilers are execution strategies that trade startup time, portability, optimization opportunity, deployment shape, and runtime complexity differently.

Open page

Reference page

Virtual Machines And Bytecode

Virtual machines and bytecode let implementations run a portable intermediate program representation while adding runtime services such as verification, garbage collection, reflection, dynamic loading, or JIT compilation.

Open page

Reference page

Compilation Targets

Compilation targets describe the operating system, CPU architecture, ABI, runtime platform, or intermediate format a toolchain can produce code for.

Open page

Reference page

Foreign Function Interface

A foreign function interface lets code in one language call functions, load libraries, exchange data, or expose callable APIs across language and runtime boundaries.

Open page

Reference page

ABI Stability

ABI stability is the ability for compiled components to keep calling each other correctly across compiler, library, language, or operating-system changes without recompilation.

Open page

Reference page

Standard Library Philosophy

Standard library philosophy describes how much capability a language project expects to ship with the language instead of leaving to third-party packages, frameworks, or platform libraries.

Open page

Concurrency concepts

Concurrency

Threads, async runtimes, message passing, lightweight tasks, memory models, and scoped task lifetimes.

6 pages

Reference page

Threads And Shared Memory

Threads and shared memory let concurrent execution contexts access the same address space, which makes communication direct but requires synchronization and clear ownership of mutable state.

Open page

Reference page

Async Await And Event Loops

Async/await and event loops structure concurrent I/O by letting tasks suspend while a runtime waits for external events, timers, sockets, or other operations to become ready.

Open page

Reference page

Goroutines And Green Threads

Goroutines, green threads, fibers, virtual threads, and lightweight processes are runtime-managed concurrency units that can be cheaper to create than operating-system threads.

Open page

Reference page

Actor Model And Message Passing

Actor-style and message-passing systems organize concurrency around isolated units that communicate by sending messages rather than by freely sharing mutable state.

Open page

Reference page

Data Races And Memory Models

Data races and memory models define when concurrent reads and writes are valid, when writes become visible, and which synchronization operations establish ordering between tasks or threads.

Open page

Reference page

Structured Concurrency

Structured concurrency treats concurrent work as a scoped tree so child tasks have clear lifetimes, cancellation, error propagation, and joining behavior.

Open page

Paradigms And Language Design concepts

Paradigms And Language Design

Programming styles and design mechanisms that shape APIs, state, errors, code generation, and boundaries.

7 pages

Reference page

Functional Programming

Functional programming is a family of language and design practices centered on functions as values, expression-oriented code, composition, immutable data, explicit effects, and modeling behavior through transformations rather than shared mutable state.

Open page

Reference page

Object-Oriented Programming

Object-oriented programming organizes programs around objects, methods, interfaces, classes, prototypes, or message dispatch, depending on the language.

Open page

Reference page

Errors As Values Vs Exceptions

Error-handling designs vary between explicit error values, exception mechanisms, result types, panics, status codes, and mixed models that reserve different paths for different failure classes.

Open page

Reference page

Metaprogramming And Macros

Metaprogramming lets programs generate, transform, inspect, or execute code or program structure, while macro systems provide language-supported code transformation at compile time or expansion time.

Open page

Reference page

Modules And Namespacing

Modules and namespaces organize code into named boundaries for visibility, reuse, dependency management, documentation, and collision avoidance.

Open page

Tooling concepts

Tooling

Ecosystem machinery for packages, builds, editors, formatting, tests, docs, and interactive work.

7 pages

Reference page

Package Managers

Package managers resolve, fetch, verify, build, install, publish, and version reusable code, shaping how a language ecosystem handles dependency risk and reuse.

Open page

Reference page

Build Systems

Build systems transform source into checked, tested, packaged, documented, or deployable artifacts while encoding dependency graphs and platform-specific build steps.

Open page

Reference page

Formatters And Linters

Formatters standardize source layout, while linters and static analyzers flag likely bugs, style drift, portability issues, or project-specific policy violations.

Open page

Reference page

Testing Cultures

Testing culture is the set of language tools, defaults, libraries, conventions, and community expectations around verifying behavior before release.

Open page

Reference page

Documentation Cultures

Documentation culture is how a language ecosystem writes, generates, tests, publishes, versions, and maintains reference material for users and contributors.

Open page