Source code - A collection of code, possibly with comments, written using a human-readable programming language, usually as plain text
Statement - A syntactic unit of an imperative programming language that expresses some action to be carried out
Expression - A syntactic entity in a programming language that may be evaluated to determine its value
Operator and Operand
Literal - A notation for representing a fixed value in source code
Template string or literal
Heredoc - A file literal or input stream literal representing a section of source code that is treated as if it were a separate file
Constant - A value that cannot be altered by the program during normal execution
Variable - An abstract storage location paired with an associated symbolic name, which contains some known or unknown quantity of information referred to as a value
Scope - The region of a computer program where the binding of a name to an entity (name binding) is valid
Data type - A collection or grouping of data values, usually specified by a set of possible values and allowed operations
Primitives - A data type provided by a programming language as a basic building block or one not defined in terms of other data types
Nominal type system - A major class of type systems, in which compatibility and equivalence of data types is determined by explicit declarations and/or the names of the types
Structural type system - A major class of type systems in which type compatibility and equivalence are determined by the type's actual structure or definition
Union type - A data type definition that specifies which of a number of permitted primitive types may be stored in its instances
Type safety - The extent to which a programming language discourages or prevents type errors
Reference - A value that enables a program to indirectly access a particular datum in the computer's memory or other storage device
Null pointer - A value saved for indicating that the pointer or reference does not refer to a valid object
Memory Management
Reference counting - A programming technique of storing the number of references, pointers, or handles to a resource
Garbage collection - A form of automatic memory management where the collector attempts to reclaim memory occupied by objects no longer in use
Smart pointer - An abstract data type that simulates a pointer while providing added features, such as automatic memory management or bounds checking
Memory safety - The state of being protected from various software bugs and security vulnerabilities when dealing with memory access
Control Flow Structures
Control flow - The order in which individual statements, instructions or function calls of an imperative program are executed or evaluated
Exception handling - The process of responding to the occurrence of exceptions during the execution of a program
Foundational Techniques & Properties
Data - Any sequence of one or more symbols; datum is a single symbol of data
Metadata - Data that provides information about other data
State - The stored information, at a given instant in time, to which a computer program or system has access
Function - A sequence of program instructions that performs a specific task, packaged as a unit
Parameter - A special kind of variable used in a subroutine or function to refer to one of the pieces of data provided as input
Anonymous function - A function definition that is not bound to an identifier
Immutable object - An object whose state cannot be modified after it is created
Generic Programming - A style of computer programming in which algorithms are written in terms of types to-be-specified-later that are then instantiated when needed
Assertion - A statement that a predicate (a Boolean-valued function) is expected to always be true at that point in the code
Autovivification - The automatic creation of a new variable or data structure as required when it is first used
Module Structure & Organization
Cohesion - The degree to which the elements inside a module belong together
Coupling - The degree of interdependence between software modules, a measure of how closely connected two routines or modules are, and the strength of the relationships between modules
Object-oriented Programming - A programming paradigm based on the object - a software entity that encapsulates data and function(s)
Abstraction - The process of hiding the complexity of a system by modeling classes appropriate to the problem and working at the most relevant level of detail
Encapsulation - The bundling of data with the methods that operate on that data, or the restricting of direct access to some of an object's components
Polymorphism - The provision of a single interface to entities of different types
Dynamic dispatch - The process of selecting which implementation of a polymorphic operation (method or function) to call at run time
Inheritance - The mechanism of basing an object or class upon another object or class, retaining similar implementation
Class - An extensible program-code-template for creating objects, providing initial values for state and implementations of behavior
Interface - An abstract type that contains no data, but defines behaviors as method signatures
Method - A procedure associated with an object, and implicitly acting upon that object
This keyword - A keyword used in many object-oriented programming languages to refer to the object associated with the current function or method call
Duck typing - An application of the duck test determining type compatibility based on the presence of certain methods and properties
Covariance and contravariance - The ways to describe how a type constructor (like list or function) behaves with respect to subtyping
Passive data structure - A record data structure that contains only public data fields and provides no methods other than implicitly for reading/writing the fields
Prototype-based programming - A style of object-oriented programming in which behavior reuse is performed via a process of reusing existing objects that serve as prototypes
Functional Programming - A programming paradigm where programs are constructed by applying and composing functions
Pattern matching - The act of checking a given sequence of tokens for the presence of the constituents of some pattern
First-class function - The property of a programming language that treats functions as first-class citizens (e.g., assignable to variables, passable as arguments)
Map - A higher-order function that applies a given function to each element of a sequence, returning a sequence containing the results
Filter - A higher-order function that processes a data structure to produce a new data structure containing only those elements for which a given predicate returns true
Reduce - A higher-order function (also known as fold) that reduces a data structure to a single value by recursively applying a combining operation
Referential transparency - A property of expressions such that an expression can be replaced with its corresponding value without changing the program's behavior
Closure - A function together with a referencing environment for the non-local variables of that function
Side-effect - An observable effect of an operation, function, or expression that modifies state variable values outside its local environment
Monad - A software design pattern with a structure that combines program fragments (functions) and wraps their return values in a type with additional computation
Currying - The technique of converting a function that takes multiple arguments into a sequence of functions that each takes a single argument
Concurrent computing - A form of computing in which several computations are executed concurrently instead of sequentially
Coroutine - A computer program component that generalizes subroutines for non-preemptive multitasking, by allowing execution to be suspended and resumed
Async/await - A syntactic feature that allows an asynchronous, non-blocking function to be structured in a way similar to an ordinary synchronous function
Futures and promises - The constructs used for synchronizing program execution, representing a proxy for a result that is initially unknown
Semaphore - A variable or abstract data type used to control access to a common resource by multiple threads in a concurrent system
Mutex - A synchronization primitive that prevents state from being modified or accessed by multiple threads of execution at the same time
Channel - A model for interprocess communication and synchronization via message passing
Thread safety - A property of computer code applicable in multi-threaded environments, ensuring correct manipulation of shared data structures
Deadlock - A situation in concurrent computing where no member of a group of entities can proceed because each waits for another member to take action
Orthogonality and DRY principle - The principle that every piece of knowledge must have a single, unambiguous, authoritative representation within a system
Separation of concerns - A design principle for separating a computer program into distinct sections
Design by Contract - An approach for designing software that prescribes formal, precise and verifiable interface specifications for software components
Law of Demeter - A design guideline for developing software, particularly object-oriented programs
SOLID - The principle of OOD - A mnemonic acronym for five design principles intended to make object-oriented designs more understandable, flexible, and maintainable
Single responsibility
Open–closed
Liskov substitution
Interface segregation
Dependency inversion
The Reactive Manifesto - A coherent approach to systems architecture where applications are responsive, resilient, elastic and message driven
Unix philosophy - A set of cultural norms and philosophical approaches to software development
Single source of truth - The practice of structuring information models and associated data schema such that every data element is stored exactly once
KISS principle - A design principle which states that most systems work best if they are kept simple rather than made complicated
Rob Pike's 5 Rules of Programming - A set of rules about where to focus optimization efforts, emphasizing measurement and the importance of data structures
The Zen of Python - A collection of 19 guiding principles for writing computer programs that influence the design of the Python programming language
The twelve-factor app - A methodology for building software-as-a-service apps that are suitable for deployment on modern cloud platforms
Codebase: One codebase tracked in revision control, many deploys.
Dependencies: Explicitly declare and isolate dependencies.
Config: Store config in the environment.
Backing services: Treat backing services as attached resources.
Build, release, run: Strictly separate build and run stages.
Processes: Execute the app as one or more stateless processes.
Port binding: Export services via port binding.
Concurrency: Scale out via the process model.
Disposability: Maximize robustness with fast startup and graceful shutdown.
Dev/prod parity: Keep development, staging, and production as similar as possible.
Logs: Treat logs as event streams.
Admin processes: Run admin/management tasks as one-off processes.
Software design pattern - A general, reusable solution to a commonly occurring problem within a given context in software design
Entity–control–boundary - An architectural pattern used in software design and analysis that helps in structuring the responsibilities of classes in an object-oriented system
Fluent interface - A method for designing object-oriented APIs based on method chaining with the goal of making the readability of the source code close to that of ordinary written prose
Model-view-controller pattern - A software design pattern commonly used for developing user interfaces that divides the related program logic into three interconnected elements
Dependency injection - A design pattern in which an object or function receives other objects or functions that it depends on
SQALE method - A method to support the evaluation of the quality of a software source code
Cyclomatic complexity - A software metric used to indicate the complexity of a program
Analysis Platform
SonarQube Server - An on-premise analysis tool designed to detect coding issues in 30+ languages, frameworks, and IaC platform
GitLab Code Coverage - A report that shows the percentage of your code that is covered by tests
GitLab Code Quality - A feature that uses CodeClimate Engines to provide code quality analysis for your projects
Formatters
EditorConfig - A file format for defining coding styles and a collection of text editor plugins that enable editors to read the file format and adhere to defined styles
Compiler - A computer program that translates computer code written in one programming language into another language
Transpiler - A type of translator that takes the source code of a program written in a programming language as its input and produces an equivalent source code in the same or a different programming language
Intermediate representation - The data structure or code used internally by a compiler or virtual machine to represent source code
Program optimization - The process of modifying a software system to make some aspect of it work more efficiently or use fewer resources
Machine code - A computer program written in machine language instructions that can be executed directly by a computer's central processing unit (CPU)
Cross compiler - A compiler capable of creating executable code for a platform other than the one on which the compiler is running
Linker - A computer system program that takes one or more object files and combines them into a single executable file
Algorithm - A finite sequence of rigorous instructions, typically used to solve a class of specific problems or to perform a computation
Analysis Techniques
Amortized analysis - A method for analyzing a given algorithm's complexity
Big O notation - A mathematical notation that describes the limiting behavior of a function when the argument tends towards a particular value or infinity
Algorithmic Paradigms
Recursion - A method of solving a computational problem where the solution depends on solutions to smaller instances of the same problem
String - A finite sequence of symbols that are chosen from a set called an alphabet
List - An abstract data type that represents a finite number of ordered values
Associative array - An abstract data type that can hold a collection of (key, value) pairs
Stack - An abstract data type that serves as a collection of elements, with two main operations: push and pop
Queue - An abstract data type that serves as a collection of elements, with two main operations: enqueue and dequeue
Priority queue - An abstract data type which is like a regular queue or stack data structure, but where additionally each element has a "priority" associated with it
Tree - An abstract data type that represents a hierarchical tree structure with a set of connected nodes
Graph - An abstract data type that is meant to implement the undirected graph and directed graph concepts from mathematics
Search tree - A tree data structure used for locating specific keys from within a set
Binary search tree (BST) - A rooted binary tree data structure with the key of each internal node being greater than all keys in the respective node's left subtree and less than the ones in its right subtree
Markle tree - A tree in which every leaf node is labelled with the cryptographic hash of a data block
Heap - A tree-based data structure that satisfies the heap property
Trie - A search tree data structure used to locate specific keys from within a set
Fenwick tree - A data structure that can efficiently update elements and calculate prefix sums in a table of numbers
Graph-based
Adjacency matrix - A square matrix used to represent a finite graph
Adjacency list - A collection of unordered lists used to represent a finite graph