https://DevOpsCloud.io -- Cloud Monk Losang Jinpa, Ph.D., MCSE/MCT, GitOps DevOps Engineer

Return to Functional and Concurrent Programming by Michel Charpentier, Functional and Concurrent Programming Glossary, Functional and Concurrent Programming, Functional Programming, Functional Languages, Functional Programming Concurrency, Functional Bibliography, Functional Courses, Functional Glossary, Awesome Functional, Functional GitHub, Functional [[Topics]]

Fair Use Source: B0B8S2QNM9 (FnCncrPg 2022)

• action - An impure subroutine that relies on side effects to modify the state of an application but does not return a (meaningful) value; sometimes also called a procedure. See also pure. Discussed in Chapter 3.

• algebraic data type - A type that combines existing types through a combination of alternatives (sum) and aggregation (product). Many standard types, including tuples, options, lists, and trees, can be defined as algebraic data types. Discussed in Chapter 5.

• anonymous function - See function literal.

• argument - An input to a function or method, such as a value or a type. Also called parameter.

• asynchronous, asynchronouslyasynchronously]] - The opposite of synchronous, synchronously]].

• callback - 1. A piece of code registered for (single, multiple, or optional) execution. Callbacks may run [[synchronously]] (as in Chapter 9) or asynchronously (as in Chapter 26). 2. The action of running such code.

• CAS - Compare-and-set.

• class - In object-oriented programming]], a template for the creation of objects]].

• concurrent - Said of multiple code executions that happen at the same time (“concurrently”). In this book, synonymous]] with parallel. Discussed in Chapter 16.

• curried, currying - A curried function consumes its first argument (or argument list) and returns another function that will use the remaining arguments (or argument lists). By currying, a function that uses a list of multiple arguments can be transformed into a function that uses multiple lists of fewer arguments. See also higher-order. Discussed in Section 9.2.

• deadlock - A situation is which several entities perpetually wait for each other in a cycle due to faulty synchronization. Discussed in Sections 22.3 and 27.7.

• exception - A disruption in the flow of program execution, typically caused by a failure and possibly handled by an exception handler. Exceptions are said to be thrown (or raised) and caught (or handled). Uncaught exceptions can cause a thread to terminate its execution.

• execution stack - A stack that keeps track of the current nesting of subroutine]]s executed by a thread: Entering a subroutine adds to the stack, exiting it removes from the stack. Also called call stack.

• expression - A code [[fragment that, through computation, evaluates to a value. In addition to expressions, programming languages may involve code without a value, evaluated for the purpose of side effects.

• extension method - A mechanism by which additional methods can be grafted onto an existing type. Discussed in Section 2.5.

• FIFO - First-in, first-out.

• function - 1. A mathematical abstraction that maps each value from a set to a unique value from another set. 2. A programming language subroutine parameterized by zero or more arguments and which produces a value. For disambiguation, see pure, side effect. Discussed in Chapter 2.

• function literal - An expression that denotes an unnamed function; also called anonymous function. Lambda expressions are a common syntax]] for function literals. Discussed in Section 9.3.

• functional - Variously defined by different authors, but often said of a programming style that emphasizes the use of pure functions, immutability, recursion, algebraic data types, higher-order functions, and/or lazy evaluation. Discussed in Chapter 1.

• future - A handle on an asynchronous computation]]. Futures vary in capabilities, and terminology is ambiguous. Futures are sometimes referred to as promises. Discussed in Chapters 25 and 26.

• garbage [[collection - A form of automatic memory management used to reclaim unused memory. The Java Virtual Machine implements a garbage collector, available to all languages that run on this platform.

• happens-before - The partial order]] that defines the Java Memory Model. Note that “happens before” and “happens-before” have a different meaning in the book. Discussed in Section 22.5.

• higher-order - Said of a function that consumes or produces other functions as values. Discussed in Chapters 9 and 10.

• immutable - That which cannot be [[changed. This term can apply to an object [[state (immutable object) or a non-reassignable variable. See also mutable. Discussed in Chapter 3.

• imperative - Said of a programming style centered on actions that modify a [[state, such as assignment [[statements. By contrast, functional programming is said to be more declarative. See also pure, side effect.

• infix - Said of a notation in which an operator appears between its two arguments, as in x + y. See also prefix, postfix.

• instance - A member value]] of a type. In object-oriented programming]] specifically, an instance of a class — that is, an object created by instantiating this class.

• JMM - Java Memory Model.

• JVM - Java Virtual Machine.

• lambda expression - A common syntax]] for function literals, named after λ-calculus, a theory of computable functions. Discussed in Section 9.3.

• lazy - Refers to]] various forms of delayed]] evaluation: lazy evaluation, lazy [[initialization, etc. Discussed in Chapter 12.

• LIFO - Last-in, first-out.

• list - 1. A generic [[term for an ordered [[collection of values]], which can be mutable or not, support efficient access by indexing or not, etc. 2. A specific data structure used in functional programming, and characterize]]d by its immutability and head/tail structure; sometimes referred to as functional list for disambiguation. Discussed in Section 3.7 and Chapter 7.

• lock - A basic synchronization [[mechanism used in concurrent programs to prevent data-sharing]] tasks from interfering with each other. Locks are only one of the many synchronizers a programming environment might offer. Discussed in Chapters 18 and 19 and Section 23.1.

• method - A function-like subroutine that is associated with a target object, which serves as one of its arguments.

• mutable - That can be [[changed. For instance, a mutable object has a state that can be modified; a mutable variable can be reassigned with a new value. See also immutable. Discussed in Chapter 3.

• node - In a graph, a vertex.

• object - The fundamental component of the state of an object-oriented program]]. An object typically encapsulates [[data and the operations that manipulate this data.

• operator - A function typically of one or two arguments, often with a symbolic name, and invoked in prefix, infix, or postfix notation.

• option - Used to represent a value that may or may not exist. An option either is empty or contains exactly one value. Options are often used as the return type of functions that do not always have a valid value to return. Discussed in Section 5.3.

• parallel - Said of multiple code executions that happen at the same time (“in parallel”). In this book, synonymous]] with concurrent. Discussed in Chapter 16.

• pattern matching - A construct, common in functional programming languages, that is used to select between alternatives and to separate component]]s of an aggregate type]]. Pattern matching can be thought of as a powerful generalization of switch. It is especially handy when dealing with algebraic data types. Discussed in Chapter 5.

• pattern-zipper - An efficient [[implementation technique for an immutable structure that is traversable (navigatable). Discussed in Section 5.6.

• postfix - Said of a notation in which an operator follows its arguments, as in x++. See also infix, prefix.

• prefix - Said of a notation in which an operator precedes its arguments, as in ++x. See also infix, postfix.

• promise - 1. A generator of a future]]. 2. Another name for a future. Discussed in Section 25.5.

• pure - Said of a programming function whose behavior depends only on its input, and which has no side effects. Pure functions are used to represent true functions (mathematical functions). See also action. Discussed in Chapter 3.

• queue - 1. A data structure for temporary [[storage of values waiting to be processed. Queue elements are often retrieved in a predefined ordering. Common orderings are first-in-first-out (FIFO), last-in-first-out (LIFO), priority [[based, or time [[based. 2. A first-in, first-out queue.

• recursion - See recursive.

• recursive - Said of a function that invokes itself in its computation, one or more times, directly or indirectly, and of a programming style that relies on such functions. Discussed in Chapter 6.

• runtime - During code execution, the period in contrast to compile time — when code is compiled.

• scope - The fragment of a program in which a particular definition is operative. A defined [[entity (variable, function, class, etc.) can be used only within its scope.

• set - 1. A mathematical abstraction of an unordered [[collection of values, without duplicates. 2. A data structure that implements this abstraction, usually with efficient [[lookup, and possibly with ordering (ordered sets) or duplicates (multisets).

• side effect - A modification of the [[state of system. Could be intentional or not. See also pure, action. Discussed in Chapter 3.

• stack - 1. A data structure that stacks elements on top of each other, typically with only the top element accessible. Sometimes referred to as a last-in-first-out (LIFO) queue. 2. The execution stack.

• stream - A sequence whose values are created over time. A stream can potentially be endless. Discussed in Chapter 12.

• switch - A programming language [[construct used to pick among several alternatives. It can be seen as a generalization of if-then-else, which is basically a switch with two branches. See also pattern matching.

• synchronization - A generic [[term for mechanisms and techniques used by threads to coordinate. Discussed in Chapters 22 and 23.

• synchronous, synchronously]] - In this book, refers to]] a computation that takes place within the program flow (“now”), as opposed to an asynchronous computation]] that does not interfere with the current flow of execution. Discussed in Chapter 16.

• tail [[recursion - A particular form of [[recursion susceptible to compiler optimizations. Discussed in Section 6.5.

• thread - Short for thread of execution. A thread represents the execution (or run) of a program. A running program contains at least one thread, but programs can also be multithreaded. Discussed in Chapter 16.

• tree - A connected, a[[cyclic graph]], typically undirected. A rooted tree identifies a vertex as the root of the tree; an ordered [[tree maintains an ordering among the children of a node (e.g., left and right in a binary [[tree).

• tuple - An ordered [[aggregate of several values, possibly of different types. A 2-tuple is referred to as a pair; a 3-tuple as a triple.

• type - An abstract characterization]] of possible values. Variables, expressions, and function input and output can all have types that constrain the actual values they might take. Types also often constrain the operations that are available on values of that type. Discussed in Chapter 15.

• value - An immutable piece of data. Values can be stored in variable]]s and data structures, returned by functions, or passed as arguments to functions.

• varargs - Short for variable-length arguments. Said of subroutines in which the number of argument]]s is not fixed. Discussed in Section 2.7.

• variable - A named reference, valid within a scope. The concept is more subtle than it sounds: Variables can refer to]] data or to code, and some variables can have their contents updated while others cannot. Discussed in Chapters 3 and 9.

Fair Use Sources:

• B0B8S2QNM9 (FnCncrPg 2022)