Abstraction (computer science)

[2] Abstraction is a fundamental concept in computer science and software engineering, especially within the object-oriented programming paradigm.

[6] The software is structured in architectures to enable humans to create the enormous systems by concentrating on a few issues at a time.

For example, consider this statement written in a Pascal-like fashion: To a human, this seems a fairly simple and obvious calculation ("one plus two is three, times five is fifteen").

Finally, assigning the resulting value of "15" to the variable labeled "a", so that "a" can be used later, involves additional 'behind-the-scenes' steps of looking up a variable's label and the resultant location in physical or virtual memory, storing the binary representation of "15" to that memory location, etc.

Without control abstraction, a programmer would need to specify all the register/binary-level steps each time they simply wanted to add or multiply a couple of numbers and assign the result to a variable.

Consider a system which handles payroll on ships and at shore offices: These layers produce the effect of isolating the implementation details of one component and its assorted internal methods from the others.

The idea is that such changes are not supposed to have any impact on client code, since they involve no difference in the abstract behaviour.

While much of data abstraction occurs through computer science and automation, there are times when this process is done manually and without programming intervention.

When abstraction proceeds into the operations defined, enabling objects of different types to be substituted, it is called polymorphism.

When it proceeds in the opposite direction, inside the types or classes, structuring them to simplify a complex set of relationships, it is called delegation or inheritance.

Common Lisp Object System or Self, for example, feature less of a class-instance distinction and more use of delegation for polymorphism.

C++ exemplifies another extreme: it relies heavily on templates and overloading and other static bindings at compile-time, which in turn has certain flexibility problems.

Consider for example a sample Java fragment to represent some common farm "animals" to a level of abstraction suitable to model simple aspects of their hunger and feeding.

If one requires a more differentiated hierarchy of animals – to differentiate, say, those who provide milk from those who provide nothing except meat at the end of their lives – that is an intermediary level of abstraction, probably DairyAnimal (cows, goats) who would eat foods suitable to giving good milk, and MeatAnimal (pigs, steers) who would eat foods to give the best meat-quality.

The two classes could be related using inheritance or stand alone, and the programmer could define varying degrees of polymorphism between the two types.

In our simple example, the domain is the barnyard, the live pigs and cows and their eating habits are the legacy constraints, the detailed analysis is that coders must have the flexibility to feed the animals what is available and thus there is no reason to code the type of food into the class itself, and the design is a single simple Animal class of which pigs and cows are instances with the same functions.

As a consequence, automatic methods for deriving information on the behavior of computer programs either have to drop termination (on some occasions, they may fail, crash or never yield out a result), soundness (they may provide false information), or precision (they may answer "I don't know" to some questions).

Model checking generally takes place on abstract versions of the studied systems.

Each level uses a system of expression involving a unique set of objects and compositions that apply only to a particular domain.

The logical level thus describes an entire database in terms of a small number of relatively simple structures.

Even though the logical level uses simpler structures, complexity remains because of the variety of information stored in a large database.