Abstracted

====================

Definition

Abstracting is the Process of simplifying or reducing complex Systems, structures, or processes to their Essential characteristics, eliminating unnecessary details and non-Essential Components. This concept has various applications in fields such as Computer Science, Engineering, and Software Development.

Origins

The term “Abstracted” originates from Mathematics and Computer Science, where abstract representations are used to simplify complex Systems and make them more manageable. In these contexts, abstracting involves reducing the Complexity of a system by eliminating non-Essential Features or Components.

Computer Science

In Computer Science, Abstraction is a fundamental concept in Software Development. It allows developers to create high-Level APIs (Application Programming Interfaces) that provide a simplified Interface for interacting with lower-Level Systems or libraries. By abstracting away Implementation details, developers can focus on defining the desired behavior of an API without worrying about the underlying Implementation.

Example:

// Original system
void foo() {
    // [Implementation](/Implementation) details
}

// [Abstracted](/Abstracted) system using a higher-<a href="/Level" class="missing-article">Level</a> [Interface](/Interface)
class MyInterface {
public:
    void bar() { foo(); }
};

Engineering

In Engineering, Abstraction is used to simplify complex Systems and make them more manageable. For example, in mechanical design, engineers may abstract away the details of a specific component or system to focus on its Essential characteristics, such as Performance or Efficiency.

Example:

# Original system
class Engine {
    def __init__(self):
        self.compressor = Compressor()
        self.cylinder = Cylinder()

    def start(self):
        # [Implementation](/Implementation) details
}

# [Abstracted](/Abstracted) system using a higher-<a href="/Level" class="missing-article">Level</a> [Interface](/Interface)
class EngineInterface {
    def start(self) { Engine.start(self); }
}

Software Development

In Software Development, Abstraction is used to create modular and reusable Code. By abstracting away Implementation details, developers can focus on defining the desired behavior of an API or component without worrying about the underlying Implementation.

Example:

// Original system
class DataStore {
    private [Database](/Database) [Database](/Database);

    public void save(String data) { [Database](/Database).save(data); }

    public String load() { return [Database](/Database).load(); }
}

// [Abstracted](/Abstracted) system using a higher-<a href="/Level" class="missing-article">Level</a> [Interface](/Interface)
[Interface](/Interface) DataStoreInterface {
    void save(String data);
    String load();
}

Benefits

The benefits of Abstraction include:

• Improved maintainability: Abstraction helps developers focus on the Essential characteristics of an API or component, making it easier to maintain and extend.
• Reduced Complexity: By eliminating unnecessary Implementation details, Abstraction simplifies complex Systems and makes them more manageable.
• Increased modularity: Abstraction promotes modular codebases by allowing developers to create independent Components that can be reused across the system.

Real-World Examples

1. Database Abstraction

Database Abstraction is a key concept in modern Software Development. By abstracting away Implementation details, developers can focus on defining the desired behavior of an API without worrying about the underlying Database schema or Implementation.

Example:

# Original system
class [Database](/Database) {
    def __init__(self):
        self.schema = Schema()

    def query(self, query) { return self.schema.execute(query); }

    def create_table(self, table_name, columns) { self.schema.create_table(table_name, columns); }
}

# [Abstracted](/Abstracted) system using a higher-<a href="/Level" class="missing-article">Level</a> [Interface](/Interface)
import sqlite3

class DatabaseInterface:
    def execute(self, query) { return sqlite3.connect('example.db').execute(query) }
    def create_table(self, table_name, columns) { sqlite3.connect('example.db').executemany('CREATE TABLE %s (%s)', [(table_name, ', '.join(columns)))] }

2. Operating System Abstraction

Operating System Abstraction is a fundamental concept in Software Development that allows developers to create high-Level APIs for interacting with lower-Level Systems.

Example:

# Original system
class [Process](/Process) {
    def run(self) { # [Implementation](/Implementation) details }
}

# [Abstracted](/Abstracted) system using a higher-<a href="/Level" class="missing-article">Level</a> [Interface](/Interface)
import os

class ProcessInterface:
    def start(self) { [Process](/Process)().run() }

3. Game Development Abstraction

Game development Abstraction is used to simplify complex Systems and make them more manageable.

Example:

# Original system
class Sprite {
    def draw(self, x, y) { # [Implementation](/Implementation) details }

    def update() { # [Implementation](/Implementation) details }
}

# [Abstracted](/Abstracted) system using a higher-<a href="/Level" class="missing-article">Level</a> [Interface](/Interface)
import pygame

class SpriteInterface:
    def draw(self, x, y) { pygame.draw.rect(pygame.display.get_surface(), self.color, (x, y)) }
    def update(self) { pygame.time.Clock().tick(60) } # [Implementation](/Implementation) details

In conclusion, Abstraction is a powerful concept that allows developers to simplify complex Systems and make them more manageable. By abstracting away Implementation details, we can focus on defining the desired behavior of an API or component without worrying about the underlying Implementation. This approach has numerous benefits, including improved maintainability, reduced Complexity, and increased modularity.