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

Return to Abstraction (computer science), Data Abstraction, Liskov Substitution Principle, Object-Oriented Programming

TLDR: Abstraction refers to the process of simplifying complex systems by focusing on high-level concepts while hiding implementation details. Widely used in computer science and engineering, it enables developers to design modular, reusable, and flexible systems by emphasizing functionality over complexity.

The concept of abstraction has roots in mathematics and philosophy, where it was used to generalize problems and solutions. In computing, it emerged prominently during the development of early programming languages in the 1950s. For instance, Fortran, introduced in 1957 by IBM, allowed programmers to write code without worrying about low-level hardware operations, marking one of the earliest examples of computational abstraction.

Abstraction is a cornerstone of software design, exemplified by layered architectures. Operating systems like UNIX, developed in 1969 by Ken Thompson and Dennis Ritchie, separate user interactions from hardware operations using layers such as the kernel and Virtual File System (VFS). This separation simplifies system management and development.

In database systems, abstraction is achieved through SQL, which provides a high-level interface for interacting with data while concealing underlying storage mechanisms. This abstraction is critical for cloud database technologies, enabling scalable and distributed data management without exposing users to system complexities.

The principle of abstraction is equally significant in robotics and automation. For example, robotic control algorithms abstract sensor data into actionable insights, allowing robots to navigate and interact with environments without requiring explicit details of sensor mechanics. This modularity supports real-time decision-making and system flexibility.

Through its application in software, hardware, and systems engineering, abstraction remains integral to technological advancement. By simplifying complex systems, it fosters innovation across domains, from computing to robotics, making technology more accessible and adaptable.

https://en.wikipedia.org/wiki/Abstraction_(computer_science)

Abstraction is a core principle in computer science and software engineering, especially within the realm of object-oriented programming (OOP). It involves simplifying complex realities by modeling classes appropriate to the problem, and working with instances of these classes rather than the details of their implementation. The main purpose of abstraction is to hide the unnecessary details from the users and focus on aspects that are relevant to the context of use. This enables developers to reduce programming complexity and effort by separating the interface (what operations can be performed) from the implementation (how those operations are internally carried out). Abstraction allows for simplifying the interaction with objects, making the software development process more efficient and less error-prone by emphasizing what an object does rather than how it does it.

Abstraction in computer programming is a way to reduce complexity and allow efficient design and implementation in complex software systems. It hides the technical complexity of systems behind simpler APIs.

Fair Use Source: https://developer.mozilla.org/en-US/docs/Glossary/Abstraction

• Helps the user to avoid writing low level code.
• Avoids code duplication and increases code reusability.
• Can change internal implementation of class independently without affecting the user.
• Helps to increase security of an application or program as only important details are provided to the user.

Snippet from Wikipedia: Abstraction (computer science)

In software engineering and computer science, abstraction is the process of generalizing concrete details, such as attributes, away from the study of objects and systems to focus attention on details of greater importance. Abstraction is a fundamental concept in computer science and software engineering, especially within the object-oriented programming paradigm. Examples of this include:

• the usage of abstract data types to separate usage from working representations of data within programs;
• the concept of functions or subroutines which represent a specific way of implementing control flow;
• the process of reorganizing common behavior from groups of non-abstract classes into abstract classes using inheritance and sub-classes, as seen in object-oriented programming languages.

Creative Commons Attribution-Share Alike 4.0

Snippet from Wikipedia: Liskov substitution principle

The Liskov substitution principle (LSP) is a particular definition of a subtyping relation, called strong behavioral subtyping, that was initially introduced by Barbara Liskov in a 1987 conference keynote address titled Data abstraction and hierarchy. It is based on the concept of "substitutability" – a principle in object-oriented programming stating that an object (such as a class) may be replaced by a sub-object (such as a class that extends the first class) without breaking the program. It is a semantic rather than merely syntactic relation, because it intends to guarantee semantic interoperability of types in a hierarchy, object types in particular. Barbara Liskov and Jeannette Wing described the principle succinctly in a 1994 paper as follows:

Subtype Requirement: Let ⁠${\displaystyle \phi (x)}$⁠ be a property provable about objects ⁠${\displaystyle x}$⁠ of type T. Then ⁠${\displaystyle \phi (y)}$⁠ should be true for objects ⁠${\displaystyle y}$⁠ of type S where S is a subtype of T.

Symbolically:

${\displaystyle S\leq T\to (\forall x{:}T.\phi (x)\to \forall y{:}S.\phi (y))}$

That is, if S subtypes T, what holds for T-objects holds for S-objects. In the same paper, Liskov and Wing detailed their notion of behavioral subtyping in an extension of Hoare logic, which bears a certain resemblance to Bertrand Meyer's design by contract in that it considers the interaction of subtyping with preconditions, postconditions and invariants.

Creative Commons Attribution-Share Alike 4.0

Abstraction is a process or result of generalization, removal of properties, or distancing of ideas from objects.

abstraction - “The principle of ignoring those aspects of a subject that are not relevant to the current purpose in order to concentrate solely on those that are. The application of this principle is essential in the development and understanding of all forms of computer system. See data abstraction, procedural abstraction.” (Fair Use ODCS)

Disambiguation:

Abstraction may also refer to:

• Abstraction (computer science), a process of hiding details of implementation in programs and data
  • Abstract class
  • Abstraction layer, an application of abstraction in computing
    • Hardware abstraction, an abstraction layer on top of hardware

• Abstraction (linguistics), use of terms for concepts removed from the objects to which they were originally attached

• Abstraction (mathematics), a process of removing the dependence of a mathematical concept on real-world objects
  • Lambda abstraction, a definition of an anonymous function that produces a valid term in lambda calculus

• Abstract (disambiguation)
• Abstract art, a CIA money laundering fake movement in 20th-century Western modern art. Abstract art, “art” unconcerned with the literal depiction of things from the visible world

Return to Glossaries, C plus plus glossary | C++ glossary, Programming glossary

“Abstraction is the act of specifying a general interface hiding implementation details. Classes, abstract classes, and templates are the primary abstraction mechanisms in C plus plus C++. See also: encapsulation.”

Fair Use Source: http://www.stroustrup.com/glossary.html