Programming Languages & Core Development Topics
Programming languages, development fundamentals, coding concepts, and core data structures. Includes syntax, algorithms, memory management at a programming level, asynchronous patterns, and concurrency primitives. Also covers core data manipulation concepts like hashing, collections, error handling, and DOM manipulation for web development. Excludes tool-specific proficiency (see 'Tools, Frameworks & Implementation Proficiency').
Asynchronous and Event-Driven Programming
Non-blocking execution models: callbacks, promises and futures, async/await, event loops, and event-driven and reactive architectures. Covers reasoning about ordering, back-pressure, and error propagation in asynchronous flows, including data-fetching patterns. Central to modern frontend, backend, and mobile runtimes.
Functional Programming
Functional-style programming: pure functions, immutability, higher-order functions, closures, currying and partial application, and memoization, along with functional reactive patterns. Covers reasoning about code as composed transformations rather than mutable state, whether in a dedicated functional language or a multi-paradigm one. Increasingly probed for frontend and data-heavy work.
Language-Level Concurrency and Multithreading
Per-language and per-runtime concurrency: the threading and async APIs each language provides (goroutines and channels in Go, threads and executors in Java, async/await runtimes, C++ std::thread and atomics), each language's memory model, and the idioms for coordinating shared state safely in that language. Covers choosing and using a language's concurrency primitives correctly; OS-level scheduling, synchronization theory, and deadlock internals live in Operating Systems & Systems Programming.
Programming Fundamentals
Language-agnostic building blocks of writing code: variables, primitive and composite data types, scope and lifetime, functions and callbacks, control flow, and expressions versus statements. Covers the mental model a candidate needs before any language-specific or algorithmic depth. The baseline literacy layer of a technical screen.
Error Handling and Defensive Programming
Making code robust against bad input and failure: exceptions versus error returns, input validation, guard clauses, graceful degradation, and designing for the unhappy path. Covers where to handle versus propagate errors and how to fail safely without hiding bugs. A recurring probe of production maturity.
Shell Scripting and Automation
Automating tasks with the command line: Bash and shell scripting, pipes and redirection, text processing, and writing custom tooling and monitoring scripts to glue systems together. Covers the scripting fundamentals infrastructure and platform engineers use daily, including automation-oriented use of general-purpose scripting. Distinct from application programming in its throwaway-to-durable tooling mindset.
Clean Code, Refactoring, and Maintainability
Writing code that other people can read, change, and keep alive over time: naming, function and module decomposition, avoiding duplication, readability, disciplined use of language idioms and design patterns, and recognizing code smells, extending into working effectively in large, aging, or unfamiliar codebases through safe incremental change, refactoring under test coverage, and managing technical debt. Covers both authoring professional-grade code beyond mere correctness and improving code you cannot rewrite without breaking it. Spans the coding-round quality signal and the seniority signal of leaving a codebase healthier than you found it.
Debugging and Performance Optimization
Finding and fixing what is wrong or slow: systematic debugging strategies, reading stack traces, profiling to locate hotspots, and optimizing execution time and memory. Covers reasoning from symptom to root cause and measuring before optimizing, including runtime, memory, and profiling analysis. Tests how a candidate operates on code they did not write.
Object-Oriented Programming and Design
The object-oriented paradigm: classes and objects, encapsulation, inheritance, polymorphism, and composition, plus SOLID and other design principles that keep object models maintainable. Covers modeling a domain in objects and defending those design choices. A staple conceptual interview across most engineering roles.