abstraction: Refers to the way objects allow subclassing and polymorphic instances of themselves to manifest, keeping core functionality and allowing these instances to change this functionality based on their context and usage needs.

bitwise: Working with data on the byte level. A bitwise comparison compares a series of single bytes or a pair of bytes to see if they are equal in binary fashion. Bitwise operators work with the bytes of data rather than their values.

clone: An instanced copy of an object and its properties and intrinsic values.

configuration file: A resource file for application configuration, usually static to the run-time application and used to initialize or configure global application resources.

context: The particular placement of each object in code flow, with the particular values and states associated with that context.

contract: A way to refer to code interfaces and abstractions; a definition of code that shares similar interfaces.

deep copy: A complete copy of the entire class encapsulation including all collections and variables, making the object independent in regard to the object from which it was cloned.

dirty updates: Refers to a unit of work when two different workflows consecutively update the same record; in effect, the last consecutive workflow cancels out the updates performed by the other workflows. This usually happens when two users update the same record without being forced to retrieve current data before the update.

encapsulation: Basic object-oriented methodology rule that allows different visibility of attributes and methods depending on their access level. Access to different levels of code and objects is set and used at compile time to create access rules around these entities.

enum: A .NET construct for a value type that supplies names for underlying primitive types.

getter: A property accessor, specific to .NET, that allows access to a private variable in a controlled fashion.

implementation: The act of creating a non-abstracted object. This is the actual object from which instances are created during run time. This would signify any non-abstract class.

inheritance: Basic object-oriented methodology rule that allows objects to be derived from other objects. These derived objects will contain, based on the access level, all the features of the parent object, but allow polymorphism of methods and attributes as allowed by the parent.

interface: Any construct or definition that allows objects with no similar linkages to connect and communicate.

lazy load: A way to defer the actual full creation and instantiation of a class to when it is actually needed. A class can be created but not fully configured until a call to an instance is made. This method allows objects with a high cost of creation to defer some of the creational aspects to occur over time instead of all at once.

lock: The lock keyword from .NET is used to keep multiple threads from accessing the code at the same time. It keeps the access to the code block concurrent and synchronized. This is how we only create one object instead of allowing each thread in turn to create another instance of the object. Java uses the synchronized keyword to perform the same functionality.

MDI (multiple document interface): Any windows forms application that uses parent and child forms with the child forms being contained inside the parent’s borders and domain.

metadata: Any language data (like XML schemas) that is used by a computational system to determine functionality by interpreting this data. Used in workflow systems where logic is not compiled directly into immutable executables, but instead is kept in an editable form and sent to the executable code to be interpreted and used to determine the logical workflow at run time.

mutex: A thread synchronization object that allows only one thread at a time to access a resource.

order of operation: The order during run time in which objects interact in a particular thread.

polymorphism: Basic object-oriented methodology rule that allows objects that share a common bond to be changed depending on their state, level of inheritance, or context. Each object can be changed or morphed, depending on its usage, from a common object or object definition. For example, a base object has a method that returns a value. This method also exists in its children, but the return value is slightly different from the parent depending on the child object type.

refactoring: This principle is one of continuous improvement. You make small changes over time to code, which leads to improvements in the overall code. You avoid large changes, preferring small changes that can create an overall effect of better, more maintainable, scaleable, and portable code. When a large change is indicated, this is no longer refactoring but is redesigning, and should be treated with the appropriate impact to your project this implies. So it is in the best interest of the developer to make sure refactoring efforts do not extend in scope to redesign.

reflection: In modern software programming, to look at the code structure of classes’ assemblies and objects, and analyze that structure during run time.

repositories: Any classes that contain other classes or collections of classes.

semaphore: A thread synchronization object that acts as a gate and allows only a set number of threads to access a resource.

shallow copy: An object that may share data with the original copy.

state: The intrinsic and extrinsic values of a class or object at run time.

static: An object or method that can be shared between different threads. Each thread can access a static method or object at any time and there is no guaranteed concurrency between these threads.

subclassing: Deals with abstraction and inheritance. The ability to create classes based on or derived from parent classes, in order to share or limit functionality.

synchronized: This Java keyword is used to keep multiple threads from accessing the code at the same time by allowing each thread to access the code inside the keyword block in sequential turns.

unit of work: A series of tasks that together complete a cycle. This refers to how a workflow accomplishes a series of tasks inside a transaction or context. Each particular function contributes and is associated with some part of a unit of work if each function depends on the other to complete a task.

virtual: Refers to objects and schemas as non-actual or unrelated to actual objects or schemas. Virtual also refers to abstraction in class children. A virtual method would be one that is non-abstract but marked for override in derived child classes.