Top 20 sOOPy Terms

Data Hiding

Data hiding is the concept of hiding internal object details within a class. This way, it ensures exclusive data access only to class members, protects object integrity, and reduces system complexity. Not to mention, it further prevents intended or unintended changes from occurring in a class.

Domain Separation

Domain separation involves the separation of "data, processes, and administrative tasks into logically defined domains" (Understanding Domain Separation). Doing so, often allows for data to be segregated between business entities, customers, partners, or sub-organizations. That is, because each domain can be controlled in different ways, including who can see and access that data.

Dynamic (Late) Binding

Dynamic binding refers to the runtime binding of when functions, methods, variables, or properties are being called or detected. That is, because the compiler does not know until run time. Hence, this term is related with polymorphism and inheritance.

Encapsulation

Encapsulation is the principle of bundling data and the functions that use them into a single unit called class. All done to prevent the misuse or interference of this data and keep it hidden from the public. For this reason, the data is not accessed directly, but rather through the functions that are present within the class. Thus, this is often done to conceal the internal representation or state of an object from the public. Hence, knowing this, this term leads to the concept of data hiding and abstraction.

Process Isolation

In computer programming, process isolation is the segregation of different computer processes to prevent them from interfering or tampering with memory (address space) they do not own. In this way, it helps programs run smoothly without any trouble.

Defense Layering

In object-oriented design, layering occurs when a system is separated into subsystems. However, they are organized in either a sequential or hierarchical way, in which each layer is linked to one another in some form. Moreover, each layer is responsible for performing a particular function in order to help accomplish the overall functionality of the system. On the other hand, defense layering is the process of arranging multiple security controls to protect data and resources against security threats.

Class

In object-oriented programming, a class is a template, or in other words a blueprint, for defining objects. Significantly, that it defines the names, the types of variables that can exist, and the methods that are common to the object being represented. For this reason, "a class can be thought of as a "type", with the objects being a "variable" of that type" (Understanding Classes and Objects).

Methods

In object-oriented programming, a method is defined as part of a class and is implemented as some behavior of an object. That being said, a class can have more than one method, in which only it can have access to the data.

Abstraction

In object-oriented programming, abstraction is the process of showing only essential information and hiding all relevant data about an object, in order to reduce complexity and allow for better efficient design. For this reason, the object is encapsulated and the data is hidden entirely.

Object

In object-oriented programming, an object is an instance of a class, which can have state, identity, and behavior.

Delegation

In object-oriented programming, delegation refers to using an object of another class and passing messages from the sending object to the receiving object. Thus, this is usually done for run time flexibility.

Inheritance

In object-oriented programming, inheritance enables a new class[es] to acquire the methods and properties of existing classes, which are referred to as subclass or derived classes. Meanwhile, the class that is used for inheritance is known as super class or base class.

Open Design

In object-oriented programming, open design adheres to the open-closed principle which states that software entities (like classes, modules, and functions) should be open for extension but closed for modification. In this way, new functionality can be added to the existing code, while still keeping much of the existing code unchanged.

Polymorphism

In object-oriented programming, polymorphism is the ability to redefine and process objects differently based on their data type or class. Accordingly, this allows an object to take on multiple forms, which can bear the same name but behave differently or have different implementations for different classes.

Simplicity

In programming, simplicity is the concept of reducing complexity and allowing "system designers and programmers to identify unwanted access paths" (Hale et al.). This way, they can implement "appropriate system security configurations" (Hale et al.).

Static (Early) Binding

In programming, static binding determines the type of object at compile time, which happens to remain unchanged throughout the execution of the program. However, to do this, the compiler must identify the class of an object.

Least Privilege

Least privilege is the practice of granting users the only processes they need to perform their job functions. However, in the circumstance where they require authorization, users must provide a justifiable need to be granted privilege for the activity.

Minimization

Minimization is the concept of "having the least functionality necessary in a program or device" (Hale et al.). All done in the attempt to "decrease the number of ways in which attackers can exploit a program or device" (Hale et al.).

Modularity

Modularity is the process of separating the functionality of a program into separate, independent components, which can be looked at individually. That is, because each component is capable for executing a specific part or function in the functionality of the program being accessed. Thus, this process is often done to debug pieces of a program.

Overloading

Overloading allows the same method name to be used for two or more different methods.