A Sea of Paradigms
Note that the paradigms in this list are not
necessarily mutually exclusive. Also, most languages or
paradigms mix multiple concepts.
This is viewing organizations and/or code in a
highly hierarchical manner. Most paradigms use
at least some hierarchies, but the concept can
be taken much further. Data, algorithms, and/or
their relationship can be hierarchical.
For example, there are special
database systems to process and control hierarchical
data more effectively than RDBMS, at least from a
performance standpoint. Pascal is known
to provide a very hierarchical algorithm and
subroutine organization. Object Oriented Programming (below)
tends to use inheritance hierarchies to classify
"objects". I find hierarchical taxonomies very limited
for business applications even though superficially
it seems like it would be more applicable.
This is my favorite.
It can focus on either making programming
for tables and RDBMS easier, and/or on using tables
themselves to organize program logic.
Another feature of Table Oriented Programming is
achieving a consistent
set of collection processing operations.
This is focusing on grouping organizations and/or
code by similar operations or by the operations that can
be done on them.
This is organizing by objects or similar categories
(subclasses) and a predetermined set of operations that operate
on them. It is my opinion that Object Oriented
Programming is over-hyped
at this time. It has it's place, but not
at the center of the Paradigm Universe.
This organizes behavior by a list or pool of rules that are
sometimes constantly cycled through. The rules can have
priorities and may be "switched-off" under some
circumstances and conditions.
These are popular in UNIX utilities. Stream paradigms
provide solutions by linking the input and output
of smaller programs or utilities, sort of like
a bunch sausages linked together. Although streaming
is highly useful for batch operations, they are
more limited in highly interactive systems.
It is also tradition that the streams be text-based
if possible. That makes them both easier to inspect
Control Panel Analogy
This emphasizes starting with or focusing on
the user interface and flushing out the rest
from there. It may also emphasize logic building
by dragging, dropping, pointing, pasting, etc.
This is using set theory, such as union, intersection, etc.
to solve some types of problems. Set theory can be used
in SQL, for example, to solve complex processing problems.
Lotus Notes is an example of a system that uses documents
as the base for work-flow and other business tasks.
Circuit-Like Visual Logic
Lab View is a product that
uses a circuit board-like layout to create program logic.
Although the product was originally designed for
electronic applications, programmers found that it could
be used for many different application types. Subroutines
are often represented by a chip-like rectangle and parameters
are fed to these subroutines by "wiring" output from
one "chip" to the input terminals of another. Special
constraints can be set up to control the sequence
and mode of the "chips".
Users familiar with it often prefer it over traditional
languages because it provides a two-dimensional way to
layout logic instead of the one-dimensional approach
inherent in text coding. (Control
Tables also offer a 2D view of logic, but in a different
The human mind uses neural networks. Although most practical
applications tend to use neural networks for pattern
matching and finding, it is possible they could be used
for much more.
Neural networks are based on the concept of nodes with
connections (wires) coming in and going out to many other
nodes. The in-coming wires often have little "gates" on
them that have a weighting factor. The weighting factor
controls how much of the signal from a given wire gets
"heard" from it's corresponding node.
The weighting factors are usually modeled with a range
of either 0 to 1, or from -1 to 1, and is the primary
way that neural networks are "programmed". (Behavior
within a node can also be changed, but this is less
Not to be confused with "procedural programming", functional
programming is where side-effects of functions on
the state of the rest the program are
impossible, or discouraged (depending the purity of your faith). Since
side-effects-free functions don't have any context, it's easier to test them
interactively (typical for Lisp systems),
and also easier for compilers to optimize precisely
because of the lack of side-effects. Lastly, 'refactoring' in
functional languages is allegedly easier, again due to the lack of context.
(Text based on notes from Philip Lijnzaad.)
Please let us know if we forgot any.
Updated: 3/22/2000, © Copyright 1999 by Findy Services
and B. Jacobs