Programming Definitions

These are some of the terms I have been introduced to over the years. In an effort to remember these and have a convenient place to reference, I have added them to this page.

Affordance: …it refers to possible actions that an actor can readily perceive.(resource)
Aggregate Function: In database management, an aggregate function or aggregation function is a function where the values of multiple rows are grouped together to form a single summary value.(resource)
Anonymous Function: a function definition that is not bound to an identifier(resource)
Argument: one of the pieces of data provided as input to the subroutine(resource)
Arity: the number of arguments or operands taken by a function or operation in logic, mathematics, and computer science.(resource)
Binary Function: a function that takes two inputs(resource)
Brownfield Development: problem spaces needing the development and deployment of new software systems in the immediate presence of existing (legacy) software applications/systems.(resource)
CQRS (Command Query Responsibility Segregation): Separate Commands from Queries on a higher bounded-context level.
CQS (Command Query Segregation): Separating Commands from Queries on a component level.
Caveat Utilitor: let the user beware(resource)
Click-through Rate (CTR): 'is the ratio of users who click on a specific link to the number of total users who view a page, email, or advertisement. It is commonly used to measure the success of an online advertising campaign for a particular website as well as the effectiveness of email campaigns.'(resource)
Conway's Law: organizations which design systems ... are constrained to produce designs which are copies of the communication structures of these organizations(resource)
Copacetic: very satisfactory(resource)
Cyclomatic Complexity: a software metric used to indicate the complexity of a program. It is a quantitative measure of the number of linearly independent paths through a program's source code.(resource)
DRY: don't repeat yourself (DRY) is a principle of software development aimed at reducing repetition of information of all kinds(resource)
De Morgan's laws: not (A or B) = not A and not B; and not (A and B) = not A or not B(resource)
Dead Letter Queue (DLQ): A dead-letter queue (DLQ), sometimes referred to as an undelivered-message queue, is a holding queue for messages that cannot be delivered to their destination queues, for example because the queue does not exist, or because it is full. Dead-letter queues are also used at the sending end of a channel, for data-conversion errors.. Every queue manager in a network typically has a local queue to be used as a dead-letter queue so that messages that cannot be delivered to their correct destination can be stored for later retrieval.(resource)
Declarative programming: a programming paradigm—a style of building the structure and elements of computer programs—that expresses the logic of a computation without describing its control flow.(resource)
Design Intent: in programming - building out objects with clear thought to the design (i.e. which properties should be required, which properties should default to null, etc).
Deterministic: Given the same input, the same result will be returned every time it is called.
Dunder: Double Underscore (i.e. Double UNDERscore
Dyadic Form (in regard to functions): a function that takes two arguments
Dynamic Scope: a variable's definition is resolved by searching its ... calling function ..., then the function which called that calling function, and so on, progressing up the call stack(resource)
Encapsulation: a language mechanism for restricting direct access to some of the object's components(resource)
Eventual Consistency: a consistency model used in distributed computing to achieve high availability that informally guarantees that, if no new updates are made to a given data item, eventually all accesses to that item will return the last updated value.(resource)
Fake: A fake is a generic term that can be used to describe either a stub or a mock object. Whether it's a stub or a mock depends on the context in which it's used. So in other words, a fake can be a stub or a mock.(resource)
Greenfield Project: developing a system for a totally new environment, without concern for integrating with other systems, especially not legacy systems.(resource)
Heisenbug: a software bug that seems to disappear or alter its behavior when one attempts to study it(resource)
Higher-order Function: a function that does at least one of the following: takes one or more functions as arguments (i.e., procedural parameters), returns a function as its result.(resource)
Idempotence: is the property of certain operations in mathematics and computer science whereby they can be applied multiple times without changing the result beyond the initial application.(resource)
Idiomatic: using a programming language in a way that is typical for that language.
Imperative Programming: a programming paradigm of software that uses statements that change a program's state. In much the same way that the imperative mood in natural languages expresses commands, an imperative program consists of commands for the computer to perform. Imperative programming focuses on describing how a program operates step by step, rather than on high-level descriptions of its expected results.(resource)
Imperative Programming: a programming paradigm of software that uses statements that change a program's state. In much the same way that the imperative mood in natural languages expresses commands, an imperative program consists of commands for the computer to perform. Imperative programming focuses on describing how a program operates step by step, rather than on high-level descriptions of its expected results.(resource)
Invocation Operator: The two parenthesis next to a function name when you invoke it.
Invoking: the specific action of a user starting (or launching or invoking) a program(resource)
Lambda Expression: a function (or a subroutine) defined, and possibly called, without being bound to an identifier(resource)
Law of Demeter: a given object should assume as little as possible about the structure or properties of anything else (including its subcomponents), in accordance with the principle of 'information hiding'(resource)
Lazy Initialization / Lazy Instantiation: Lazy initialization of an object means that its creation is deferred until it is first used.(resource)
Lexical Scope: a variable's definition is resolved by searching its containing block or function, then if that fails searching the outer containing block, and so on(resource)
Linear Time: if its time complexity is O(n). Informally, this means that for large enough input sizes the running time increases linearly with the size of the input. For example, a procedure that adds up all elements of a list requires time proportional to the length of the list.(resource)
Memoization: memoization or memoisation is an optimization technique used primarily to speed up computer programs by storing the results of expensive function calls and returning the cached result when the same inputs occur again.(resource)
Mise en place: a French culinary phrase which means 'putting in place' or 'everything in its place'. It refers to the setup required before cooking, and is often used in professional kitchens to refer to organizing and arranging the ingredients (e.g., cuts of meat, relishes, sauces, par-cooked items, spices, freshly chopped vegetables, and other components) that a cook will require for the menu items that are expected to be prepared during a shift.(resource)
Mock: A mock object is a fake object in the system that decides whether or not a unit test has passed or failed. A mock starts out as a Fake until it's asserted against.(resource)
Model: Represents an object and has methods, fields, or properties for that object (i.e. Student, Car). These are typically nouns. A model could also hold multiple smaller models (i.e. CarRepository or StudentCollection).
Monadic Form (in regard to functions): a function that takes one argument
Observer Pattern: a software design pattern in which an object, called the subject, maintains a list of its dependents, called observers, and notifies them automatically of any state changes, usually by calling one of their methods.(resource)
Open/Closed Principle: 'software entities (classes, modules, functions, etc.) should be open for extension, but closed for modification'; that is, such an entity can allow its behaviour to be extended without modifying its source code.(resource)
Operator Precedence: is a collection of rules that reflect conventions about which procedures to perform first in order to evaluate a given mathematical expression(resource)
Parameter: An ordered list of parameters is usually included in the definition of a subroutine, so that, each time the subroutine is called, its arguments for that call can be assigned to the corresponding parameters.(resource)
Parkinson's Law: 'work expands so as to fill the time available for its completion.'(resource)
Plain Old Java Object (POJO): an ordinary Java object, not bound by any special restriction.(resource)
Polymorphism: when a name denotes instances of many different classes related by some common superclass(resource)
Predicate: a Boolean-valued function P: X→ {true, false}(resource)
Primitive Data Type: a data type provided by a programming language as a basic building block. Most languages allow more complicated composite types to be recursively constructed starting from basic types.(resource)
Pure Function: Does not have side effects and is deterministic.
SUT: System Under Test
Separate Query from Modifier: Split the method into two separate methods. As you would expect, one of them should return the value and the other one modifies the object.(resource)
Service: a class that contains methods which can be used by model(s) (i.e. CarTuner, StudentGradeCalculator). These are typically verbs.
Short-Circuiting: Since a statement involving && is only true if both of the statements are true, the computer doesn't evaluate the second part of the conditional if the first part is false. This helps it save time by avoiding unnecessary calculations.(resource)
Single Responsibility Principle: every module or class should have responsibility over a single part of the functionality provided by the software, and that responsibility should be entirely encapsulated by the class(resource)
Snake Cased: naming variables so that two words are separated with an underscore such as: 'the_variable' or 'Read_line'.
Soft Delete: 'marking a database entry as deleted so that it no longer appears to the end user. On the backend a boolean flag is being set that prevent this entry from being shown on the frontend of the site.
Stub: A stub is a controllable replacement for an existing dependency (or collaborator) in the system. By using a stub, you can test your code without dealing with the dependency directly. By default, a stub starts out as a fake.(resource)
Sturgeon's law: an adage that states that 'ninety percent of everything is crap.'(resource)
Tail Call: a subroutine call performed as the final action of a procedure(resource)
Tail Recursion: the same subroutine being called again later in the call chain(resource)
Temporal coupling: When two actions are bundled together into one module just because they happen to occur at the same time.(resource)
Transclusion: Transclusion means the inclusion of the content of one document within another document by reference.(resource)
Transitive Relation: an element a is related to an element b, and b is in turn related to an element c, then a is also related to c(resource)
Type Coercion: different ways of changing an entity of one data type into another ... the word coercion is used to denote an implicit conversion, either during compilation or during run time.(resource)
Unary Function: a function that takes one argument(resource)
WET: Violations of DRY are typically referred to as WET solutions, which is commonly taken to stand for either 'write everything twice', 'we enjoy typing' or 'waste everyone's time'.(resource)
Yagne: you ant gonna need it
Zeller's Congruence: an algorithm devised by Christian Zeller in the 19th century to calculate the day of the week for any Julian or Gregorian calendar date.(resource)