Programming
How code is organized, and how it runs on many cores at once.
23 concepts · 42 technologies · 3 comparisons · 1 real stack
Concepts
Start with Programming languages- Programming languages15 technologiesWhat actually separates one language from another in practice: how the code runs, when types are checked, who frees memory, and which styles of program and concurrency it makes easy.
- Static dispatchThe compiler decides which function each call runs, so the program jumps straight to it, or skips the call by inlining it.
- Dynamic dispatchThe function a call runs is chosen at run time from the object it’s called on, usually through a table of function pointers.
- Runtime virtual machines3 technologiesA program that runs other programs: compilers emit portable bytecode, and the runtime loads it, compiles the busy parts to machine code, collects garbage and schedules work on whatever machine it lands on.
- Foreign function interfaces2 technologiesHow code in one language calls functions compiled from another: both sides meet at the platform’s C calling convention, and glue code converts values and settles who frees what.
- Data structuresWays to lay data out in memory so the operations a program runs most are fast; you choose one by the operations you need and what each one costs.
- Purely functional data structures6 technologiesCollections that are never changed in place: every update returns a new version that shares most of its memory with the old one, and every old version stays valid.
- Object-oriented programming3 technologiesBundle data with the code allowed to change it into objects, and let callers ask an object to do something without knowing how it does it.
- Functional programming5 technologiesBuild programs from functions that take values and return new values, without changing anything else along the way.
- MonadsA wrapper type plus one rule for chaining steps, so the plumbing (missing values, errors, waiting, state) is written once instead of after every step.
- DRY: Don’t Repeat YourselfEvery fact a system knows should live in one place, so changing a rule is one edit; it is about duplicated knowledge, not about code that happens to look alike.
- Service layerPut business logic in stateless services, like `OrderService.placeOrder`, that load plain data objects, apply the rules, and save the result.
- Data transfer objects1 technologyA plain object that only carries data across a boundary (a network call, an API, a message), shaped for that trip rather than for the business logic behind it.
- Object-relational mapping9 technologiesA library that turns rows in relational tables into objects in your program and back, so ordinary code can read and save data without hand-writing every SQL statement.
- Errors and exceptionsHow a function reports that it couldn’t do its job, either as a value the caller has to check or as an exception that jumps up the call stack to whoever catches it, and why expected failures and bugs deserve different treatment.
- Optional valuesA type that says a value may be missing, so the compiler makes you handle “nothing” before you use it, instead of a null that crashes at run time.
- Base Class Library patternsThe few recurring shapes the .NET Base Class Library uses everywhere (`IDisposable` and `using`, `TryParse`, `Task`-returning `Async` methods, `EventHandler<T>` events, `yield` iterators), so every .NET type behaves the way callers already expect.
- MultithreadingSeveral threads of one program run at once, on separate cores or taking turns, all sharing the same memory.
- Amdahl’s lawThe part of a job that can’t run in parallel caps how much faster more workers can make it.
- Synchronous and asynchronous executionWhether a call makes its caller wait for the result (synchronous) or hands control back at once and delivers the result later (asynchronous), and the ways languages let code wait without holding a thread.
- Event loopOne thread waits on thousands of sockets at once and runs a short callback whenever one of them is ready.
- Binary parsing and encoding5 technologiesReading and writing bytes laid out in a fixed format, such as packet headers, file headers and firmware messages, without trusting what those bytes claim about themselves.
- UI libraries2 technologiesReusable interface parts: styled components you drop in and theme, or headless ones that handle state, keyboard and accessibility while you write the markup and styles.
