Abstraction/Concretization - What for?
Abstraction has three well-known functions [WOMB]
in creating abstractions that help mananging complexity;
correspondingly there are three abstraction processes/techniques and relations,
and three kinds of results (concepts, abstractions).
- Aggregation (decomposition):
One function of abstraction is to allow to treat
several individual entities (`parts', `components', `constituents')
as one
by ignoring the distinction between
and subsuming them under one `composite' individual.
For example, we can say "the triumvirate ruled Rome 60-49,"
and ignore the distinction between Julius Caesar, Crassus, and Pompeius.
In programming, procedural abstraction, eg.,
allows to treat several, more primitive computational steps as one.
(What steps these can be depends on your model of computation[^].)
In the extreme, it allows to treat the whole program as one large step,
which is/was recursively decomposed in software development
to smaller steps (functional decomposition).
- Process of decomposition:
The problem solution strategy of divide & conquer
means to decompose a problem without direct solution
recursively into sub-problems to be solved independently;
the aggregation of the final sub-problems' solutions
constitutes the initial problem's solution [Quib].
- Classification (exemplification):
Another function is to
subsume all entities (`instances', [at base level only?] `particulars')
sharing certain selected (``essential'') properties
under one `class' (or `type', `kind'),
so that they can be treated uniformly aka. generically.
For example, we can investigate the properties of
all systems with a finite number of states (finite automata),
not just of particular ones,
and make laws for all citizens, broadcasters, etc.,
not just for particular ones.
In programming, the classification of values into types enables us, eg.,
to write algorithms that work with all values of a certain type.
«As soon as we start working in an untyped universe,
we begin to organize it in different ways for different purposes.
Types arise informally in any domain to
categorize objects according to their usage and behavior.
The classification of objects in terms of the purposes for which they are used
eventually results in a more or less well-defined type system.
Types arise naturally, even starting from untyped universes»
[UTDAP].
- Relation of classification/exemplification:
Note that from the three, only classification is non-transitive:
Although Democracy and Dictatorship are instances of
Form-of-Government,
the U.S.A. (an instance of Democracy) is not a Form-of-Government.
- Generalization (specialization):
Finally, abstraction can serve to
subsume all concepts (`sub-concepts', `species', eg., subtypes, subclasses)
defined by a common subset of properties
under one concept (`super-concept', `genus', eg., supertype, superclass)
in order to increase the scope of uniform treatment.
For example, we can treat as irrelevant the difference
between constitutional monarchies (the U.K., Canada, Spain, Japan)
and republics (the U.S.A., France, Germany, Russia),
and call them democracies.
That is, Democracy is here the common generalization
of Republic and Consitutional-Monarchy.
In programming, object-oriented programming made generalization popular
in the form of subclassing (see there).
- Relation of generalization/specialization:
«A concept C is considered to be a specialization of another concept C'
if all phenomena belonging to the extension of C
also belong to the extension of C'
[C H Pedersen: Extending Ordinary Inheritance Schemes to Include Generalization;
407-417: OOPSAL'89].
Thus, C differs from C'
in that it may have more specific properties» [VOOP].
- Process of concretization:
«The generalization/specialization ordering complements classification
by allowing classes of entities to be described in terms of other
(already described) classes» [VOOP].
| |
