Software Engineering - What are OOP's Jargons and Complexities?

Author

What are OOP's Jargons and Complexities?

Xah Lee

2005-05-23, 3:57 pm

What are OOP's Jargons and Complexities
Xah Lee, 20050128

The Rise of Classes, Methods, Objects

In computer languages, often a function definition looks like this:
subroutine f (x1, x2, ...) {
variables ...
do this or that
}

In advanced languages such as LISP family, it is not uncommon to define
functions inside a function. For example:
subroutine f (x1, x2, ...) {
variables...
subroutine f1 (x1...) {...}
subroutine f2 (x1...) {...}
}

Often these f1 f2 inner functions are used inside f, and are not
relevant outside of f. Such power of the language gradually developed
into a style of programing. For example:
subroutine a_surface () {
coordinatesList =3D ...;
subroutine translate (distance) {...}
subroutine rotate (angle) {..}
}

Such a style is that the a_surface is no longer viewed as a function.
But instead, a boxed set of functions, centered around a piece of data.
And, all functions for manipulating this piece of data are all embodied
in this function. For example:
subroutine a_surface (arg) {
coordinatesList =3D ...
subroutine translate (distance) {set coordinatesList to translated
version}
subroutine rotate (angle) {set coordinatesList to rotated version}
subroutine return () {return coordinatesList}

if (no arg) {return coordinatesList}
else { apply arg to coordinatesList }
}

In this way, one uses a_surface as a data, which comes with its owe set
of functions:
mySurface =3D a_surface();
mySurface(rotate(angle)); // now the surface data has been
rotated
mySurface(translate(distance)); // now its translated
newSurface =3D mySurface(return())

So now, a_surface is no longer viewed as a subroutine, but a boxed set
of things centered around a piece of data. All functions that work on
the data are included in the boxed set. This paradigm possible in
functional languages has refined so much so that it spread to other
groups and became known as Object Oriented Programing, and complete
languages with new syntax catered to such scheme emerged.

In such languages, instead of writing them like this:
mySurface =3D a_surface();
mySurface(rotate(angle));

the syntax is changed to like this, for example:
mySurface =3D new a_surface();
mySurfaceRotated =3D mySurface.rotate(angle);

In such languages, the super subroutine a_surface is no longer called a
function or subroutine. It is now called a =E2=80=9CClass=E2=80=9D. And now=
the
variable holding the function "mySurface =3D a_surface()" is now called a
=E2=80=9CObject=E2=80=9D. Subroutines inside the function a_surface() are n=
o longer
called inner-subroutines. They are called =E2=80=9CMethods=E2=80=9D. The ac=
t of
assigning a super-subroutine to a variable is called instantiation.

This style of programing and language have become so fanatical that in
such dedicated languages like Java, everything in the language are
=E2=80=9CClasses=E2=80=9D. One can no longer just define a variable or subr=
outine.
Instead, one creates these meta-subroutine =E2=80=9CClasses=E2=80=9D. Every=
thing
one do are inside Classes. And one assign Classes inside these Classes
to create =E2=80=9CObjects=E2=80=9D. And one uses =E2=80=9CMethods=E2=80=9D=
to manipulate
Objects. In this fashion, even basic primitives like numbers, strings,
and lists are no longer atomic entities. They are now Classes.

For example, in Java, a string is a class String. And inside the class
String, there are Methods to manipulate strings, such as finding the
number of chars, or extracting parts of the string. This can get very
complicated. For example, in Java, there are actually two Classes of
strings: One is String, and the other is StringBuffer. Which one to use
depends on whether you intend to change the data.

So, a simple code like this in normal languages:
a =3D "a string";
b =3D "another one";
c =3D join(a,b);
print c;

or in lisp style
(set a "a string")
(set b "another one")
(set c (join a b))
(print c)

becomes in pure OOP languages:
public class test {
public static void main(String[] args) {
String a =3D new String("a string");
String b =3D new String("another one");
StringBuffer c =3D new StringBuffer(40);
c.append(a); c.append(b);
System.out.println(c.toString());
}
}

Here, the "new String" creates a String object. The "new
StringBuffer(40)" creates the changeable string object StringBuffer,
with room for 40 chars. "append" is a method of StringBuffer. It is
used to join two Strings.

Notice the syntax "c.append(a)", which we can view it as calling a
inner subroutine "append", on a super subroutine that has been assigned
to c, where, the inner subroutine modifies the inner data by appending
a to it.

And in the above Java example, StringBuffer class has another method
"toString()" used to convert this into a String Class, necessary
because System.out.println's parameter requires a String type, not
StringBuffer.

For a example of the complexity of classes and methods, see the Java
documentation for the StringBuffer class at
http://java.sun.com/j2se/1.4.2/docs...ringBuffer.html
(local copy)

In the same way, numbers in Java have become a formalization of many
classes: Double, Float, Integer, Long... and each has a bunch of
"methods" to operate or convert from one to the other.

Instead of
aNumber =3D 3;
print aNumber^3;

In Java the programer needs to master the ins and outs of the several
number classes, and decide which one to use. (and if a program later
needs to change from one type of number to another, it is often
cumbersome.)

This Object Oriented Programing style and dedicated languages (such as
C++, Java) have become a fad like wild fire among the programing mass
of ignoramuses in the industry. Partly because of the data-centric new
perspective, partly because the novelty and mysticism of new syntax and
jargonization.

It is especially hyped by the opportunist Sun Microsystems with the
inception of Java, internet, and web applications booms around 1995. At
those times, OOP (and Java) were thought to revolutionize the industry
and solve all software engineering problems, in particular by certain
"reuse of components" concept that was thought to come with OOP.

As part of this new syntax and purity, where everything in a program is
of Classes and Objects and Methods, many complex issues and concept
have arisen in OOP.

We now know that the jargon Class is originally and effectively just a
boxed set of data and subroutines, all defined inside a subroutine. And
the jargon "Object" is just a variable that has been set to this super
subroutine. And the inner subroutines are what's called Methods.

----------
to be continued tomorrow.

This is part of an installment of the article
=E2=80=9CWhat are OOP's Jargons and Complexities=E2=80=9D
by Xah Lee, 20050128. The full text is at
http://xahlee.org/Periodic_dosage_dir/t2/oop.html

=C2=A9 Copyright 2005 by Xah Lee. Verbatim duplication of the complete
article for non-profit purposes is granted.

The article is published in the following newsgroups:
comp.lang.c,comp.lang.c++,comp.lang.lisp,comp.unix.programmer
comp.lang.python,comp.lang.perl.misc,comp.lang.scheme,comp.lang.java.progra=
mmer
comp.lang.functional,comp.object,comp.software-eng,comp.software.patterns

Xah
xah@xahlee.org
=E2=88=91 http://xahlee.org/

Laurent Bossavit

2005-05-23, 3:57 pm

Xah,

> The article is published in the following newsgroups:

Are you interested in critical review of the article, or just trying to
make new friends ?

Laurent

Stefaan A Eeckels

2005-05-23, 8:56 pm

On 23 May 2005 08:40:28 -0700
"Xah Lee" <xah@xahlee.org> wrote:

> to be continued tomorrow.

Hopefully not.

___________________
/| /| | |
||__|| | Please do |
/ O O\__ NOT |
/ \ feed the |
/ \ \ troll |
/ _ \ \ ______________|
/ |\____\ \ ||
/ | | | |\____/ ||
/ \|_|_|/ \ __||
/ / \ |____| ||
/ | | /| | --|
| | |// |____ --|
* _ | |_|_|_| | \-/
*-- _--\ _ \ // |
/ _ \\ _ // | /
* / \_ /- | - | |
* ___ c_c_c_C/ \C_c_c_c____________

--
Stefaan
--
As complexity rises, precise statements lose meaning,
and meaningful statements lose precision. -- Lotfi Zadeh

Phlip

2005-05-23, 8:56 pm

Stefaan A Eeckels wrote:

>
> Hopefully not.

Stefaan, accusations of trolling are a mud that splatters easily on the
thrower.

--
Phlip
[url]http://www.c2.com/cgi/wiki?Z

Land[/url]

Stefaan A Eeckels

2005-05-23, 8:56 pm

On Mon, 23 May 2005 19:03:51 GMT
"Phlip" <phlip_cpp@yahoo.com> wrote:

> Stefaan, accusations of trolling are a mud that splatters easily on the
> thrower.

It's a foul-mouthed troll in Unix newsgroups, and posted this same
drivel in comp.lang.c,comp.lang.c++,comp.lang.lisp, and
comp.unix.programmer (but as a separate post from the one here). One of
its previous efforts (crossposted to comp.lang.lisp,comp.lang.scheme,
comp.lang.c, comp.unix.programmer and comp.lang.functional) started as
follows:

| Let me expose one another XXXXing incompetent part of Python doc, in
| illustration of the Info Tech industry's masturbation and ignorant
| nature.

and another one (cross-posted to comp.unix.programmer,alt.unix.g

s,
comp.os.linux.advocacy and comp.unix.solaris):

| please spread the debunking of the truncating line business of the
| XXXXing unix-loving XXXXheads, as outlines here:
| http://xahlee.org/UnixResource_dir/...ncate_line.html

The less reaction it gets, the faster it'll disappear.

--
Stefaan
--
As complexity rises, precise statements lose meaning,
and meaningful statements lose precision. -- Lotfi Zadeh

xah@xahlee.org

2005-05-26, 8:56 am

The Rise of =E2=80=9CStatic=E2=80=9D versus =E2=80=9CInstance=E2=80=9D vari=
ables

In a normal programing language, variables inside functions are used by
the function, called local variables.

In OOP paradigm, as we've seen, super-subroutines (classes) are
assigned to variables (instantiation), and the inner-subroutines
(methods) are called thru the variables (objects). Because of this
mechanism, what's once known as local variables (class variables) can
now also be accessed thru the assigned variable (objet) by design. In
OOP parlance, this is to say that a class's variables can be accessed
thru the object reference, such as in myObject.data=3D4. For example:
mySurface =3D new a_surface();
mySurface.coordinatesList=3D{...} // assign initial coordinates

However, sometimes a programmer only needs a collection of variables.
For exmple, a list of colors:
black =3D "#000000";
gray =3D "#808080";
green =3D "#008000";

In pure OOP, data as these now come with a subroutine (class) wrapper:
class listOfColors() {
black =3D "#000000";
gray =3D "#808080";
green =3D "#008000";
}

Now to access these values, normally one needs to assign this
subroutine (class) to a variable (instantiation) as to create a object:
myColors =3D new listOfColors(); // instantiation! (creating a "object")
newColor =3D myColors.black;

As a workaround of this extraneous step is the birth of the concept of
=E2=80=9Cstatic=E2=80=9D variables. (with the keyword =E2=80=9Cstatic=E2=80=
=9D in Java) When a
variable is declared static, that variable can be accessed without
needing to instantiate its class. Example:
class listOfColors() {
static black =3D "#000000";
static gray =3D "#808080";
static green =3D "#008000";
}
newColor =3D listOfColors.black; // no instantiation required

The issue of staticality is also applicable to inner-subroutines
(methods). For example, if you are writing a collection of math
functions such as Sine, Cosine, Tangent... etc, you don't really want
to create a instance in order to use. Example:
class mathFunctions() {
static sin (x) {...}; // a static method
...
}
print mathFunctions.sin(1); // no need to create object before use

The non-static variant of variables and methods are called =E2=80=9Cinstance
variables=E2=80=9D or =E2=80=9Cinstance methods=E2=80=9D, or collectively =
=E2=80=9Cinstance
members=E2=80=9D. Note that static members and instance members are very
different. With static members, variables and methods can be called
without creating a object. But more subtly, for a static variable,
there is just one copy of the variable; for instance variables, each
object maintains its own copy of the variable. A class can declare just
some variables static. So, when multiple objects are created from the
class, some variables will share values while others having independent
copies. For example:
class a_surface() {
static pi; // a static variable
coordinatesList; // a instance variable
...
};
a_surface.pi=3D3.1415926; // assign value of pi for all
a_surface objects
mySurface1 =3D new a_surface();
mySurface1.coordinatesList=3D{...} // assign coordinates to one a_surface
object
mySurface2 =3D new a_surface();
mySurface2.coordinatesList=3D{...} // assign coordinates to another
a_surface object

The issues of static versus instance members, is one complexity arising
out of OOP.

------------
to be continued tomorrow.

This is part of an installment of the article
=E2=80=9CWhat are OOP's Jargons and Complexities=E2=80=9D
by Xah Lee, 20050128. The full text is at
http://xahlee.org/Periodic_dosage_dir/t2/oop.html

=C2=A9 Copyright 2005 by Xah Lee. Verbatim duplication of the complete
article for non-profit purposes is granted.

The article is published in the following newsgroups:
comp.lang.c,comp.lang.c++,comp.lang.lisp,comp.unix.programmer
comp.lang.python,comp.lang.perl.misc,comp.lang.scheme,comp.lang.java.progra=
mmer
comp.lang.functional,comp.object,comp.software-eng,comp.software.patterns

Xah
xah@xahlee.org
=E2=88=91 http://xahlee.org/

xah@xahlee.org

2005-05-28, 8:56 am

The Rise of =E2=80=9CConstructors=E2=80=9D and =E2=80=9CAccessors=E2=80=9D

A instantiation, is when a variable is assigned a super-subroutine
(class). A variable assigned such a super-subroutine is now called a
instance of a class or a object.

In OOP practice, certain inner-subroutines (methods) have developed
into specialized purposes. A inner-subroutine that is always called
when the super-subroutine is assigned to a variable (instantiation), is
called a constructor or initializer. These specialized
inner-subroutines are sometimes given a special status in the language.
For example in Java the language, constructors are different from
methods.

In OOP, it has developed into a practice that in general the data
inside super-subroutines are supposed to be changed only by the
super-subroutine's inner-subroutines, as opposed to by reference thru
the super-subroutine. (In OOP parlance: class's variables are supposed
to be accessed/changed only by the class's methods.) Though this
practice is not universal or absolute. Inner-subroutines that change or
return the value of variables are called accessors. For example, in
Java, a string class's method length() is a accessor.

Because constructors are usually treated as a special method at the
language level, its concept and linguistic issues is a OOP machinery
complexity, while the Accessor concept is a OOP engineering complexity.

-----
to be continued tomorrow.

This is part of an installment of the article
=E2=80=9CWhat are OOP's Jargons and Complexities=E2=80=9D
by Xah Lee, 20050128. The full text is at
http://xahlee.org/Periodic_dosage_dir/t2/oop.html

=C2=A9 Copyright 2005 by Xah Lee. Verbatim duplication of the complete
article for non-profit purposes is granted.

The article is published in the following newsgroups:
comp.lang.c,comp.lang.c++,comp.lang.lisp,comp.unix.programmer
comp.lang.python,comp.lang.perl.misc,comp.lang.scheme,comp.lang.java.progra=
mmer
comp.lang.functional,comp.object,comp.software-eng,comp.software.patterns

Xah
xah@xahlee.org
=E2=88=91 http://xahlee.org/

xah@xahlee.org

2005-05-28, 8:56 am

corba.object

2005-05-30, 8:57 pm

I think u have got most of thigns correct except things about OO.

The jargons, if u like to call it so, of OO are
1. Abstraction - The most powerful benefit that we derive form
programming OO way is abstraction. Modeling of problem space in terms
of objects, i.e the software entities should tend to emulate actual
behaviour as envisaged or showed by real world entity.

Other jargons used in context of OO are
polymorphism

then inheritance

may not be in same order for everyone.

Now Computer world needs more of people with better abstraction than
g

s who tends to lost in subroutings, ADT, loop, switch, recursive
calls, inline etc.

xah@xahlee.org

2005-05-31, 9:09 am

the Rise of =E2=80=9CAccess Specifiers=E2=80=9D (or, the Scoping Complexity=
of OOP)

In programing, a variable has a scope =E2=80=94 meaning where the variable
can be seen. Normally, there are two basic models: dynamically scoped
and lexically scoped. Dynamic scoping is basically a time based system,
while lexical scoping is text based (like =E2=80=9Cwhat you see is what you
get=E2=80=9D). For example, consider the following code:
subroutine f() {return y}
{y=3D3; print f()}

In dynamic scoping, the printed result is 3, because during evaluation
of the block all values of y is set to 3. In lexical scoping, =E2=80=9Cy=E2=
=80=9D
is printed because any y in the block is set to 3 before f is called.
With regards to language implementation, Dynamic Scoping is the
no-brainer of the two, and is the model used in earlier languages. Most
of the time, lexical scoping is more natural and desired.

Scoping is also applicable to subroutines. That is to say, where
subroutines can be seen. A subroutine's scope is usually at the level
of source file (or a concept of a module/package/library), because
subroutines are often used in the top level of a source file, as
opposed to inside a code block like variables.

In general, the complexity of scoping is really just how deeply nested
a name appears. For example see in the following code:
name1; // top level names. Usually subroutines, or global
variables.
{
name2 // second level names. Usually variables inside subroutines.
{
name3 // deeper level names. Less often used in structured
programing.
}
}

If a programing language uses only one single file of commands in
sequence as in the early languages such as BASIC, there would be no
scoping concept. The whole program is of one single scope.

OOP has created a immense scoping complexity because its mode of
computing is calling nested subroutines (methods) inside subroutines
(classes). We detail some aspects in the following.

In OOP, variables inside subroutines (class variables) can also be
accessed thru a reference the subroutine is assigned to (that is, a
object). In OOP parlance: a variable in a class has a scope, while the
same variable when the class is instantiated (a objet) is a different
scoping issue. In other words, OOP created a new entity =E2=80=9Cvariable
thru reference=E2=80=9D that comes with its own scoping issue. For example:
class a_surface() {
coordinates=3D{...}; // a variable
}

class main() {
mySurface =3D new a_surface();
mySurface.coordinates =3D {...}; // the same variable
}

In the above code, the variable =E2=80=9Ccoordinates=E2=80=9D appears in two
places. Once as defined inside a_surface, and once as a instantiated
version of a_surface, that is, a object. The variable as thru the
object reference apparently has a entirely different scoping issue than
the same variable inside the subroutine (class) definition. The
question for OOP language designers is: what should the scope be for
variables referred thru objects? Within the class the object is
created? within the class the variable is defined? globally? (and what
about inherited classes? (we will cover OOP inheritance later))

As we've seen, methods are just inner-subroutines, and creating objects
to call methods is OOP's paradigm. In this way, names at the
second-level programing structure often associate with variables (and
inner-subroutines), is now brought to the forefront. This is to say,
the scoping of subroutines are raised to a level of complexity as the
scoping of variables. (they are now both in the 2nd level of names (or
deeper).)

All in all, the scoping complexities of OOP as applied to different OOP
entities (classes, class variables, class's methods, object variables
and methods) is manifested as access specifiers in Java. In Java,
access specifiers are keywords =E2=80=9Cprivate=E2=80=9D, =E2=80=9Cprotecte=
d=E2=80=9D,
=E2=80=9Cpublic=E2=80=9D, used to declare the scope of a entity. Together w=
ith a
default scope of no-declaration, they create 4 types of scope, and have
entirely different effects when used upon a variable, a method, a
constructor, and a class.

See this tutorial of Java's access specifiers for detail:
http://xahlee.org/java-a-day/access_specifiers.html
-----
to be continued tomorrow.

This is part of an installment of the article
=E2=80=9CWhat are OOP's Jargons and Complexities=E2=80=9D
by Xah Lee, 20050128. The full text is at
http://xahlee.org/Periodic_dosage_dir/t2/oop.html

=C2=A9 Copyright 2005 by Xah Lee. Verbatim duplication of the complete
article for non-profit purposes is granted.

The article is published in the following newsgroups:
comp.lang.c,comp.lang.c++,comp.lang.lisp,comp.unix.programmer
comp.lang.python,comp.lang.perl.misc,comp.lang.scheme,comp.lang.java.progra=
mmer
comp.lang.functional,comp.object,comp.software-eng,comp.software.patterns

Xah
xah@xahlee.org
=E2=88=91 http://xahlee.org/

xah@xahlee.org

2005-06-03, 8:57 pm

The Rise of =E2=80=9CInheritance=E2=80=9D

In well-thought-out languages, functions can have inner functions, as
well as taking other functions as input and return function as output.
Here are some examples illustrating the use of such facilities:
subroutine generatePower(n) {
return subroutine (x) {return x^n};
}

In the above example, the subroutine generatePower returns a function,
which takes a argument and raise it to nth power. It can be used like
this:
print generatePower(2)(5) // prints 25

Example: fixedPoint:
subroutine fixedPoint(f,x) {
temp=3Df(x);
while (f(x) !=3D temp) {
temp=3Df(temp);
}
return temp;
}

In the above example, fixedPoint takes two arguments f and x, where f
is taken to be a function. It applies f to x, and apply f to that
result, and apply f to that result again, and again, until the result
is the same. That is to say, it computes f[f[f[...f[x]...]]].
FixedPoint is a math notion. For example, it can be employeed to
implement Newton's Method of finding solutions as well as many problems
involving iteration or recursion. FixedPoint may have a optional third
parameter of a true/false function fixedPoint(func,arg,predicate) for
determining when the nesting should stop. In this form, it is
equivalent to the =E2=80=9Cwhile loop=E2=80=9D in procedural languages.

Example: composition:
subroutine composition(a,b,c,...) {
return subroutine {a(b(...c...))};
}

The above example is the math concept of function composition. That is
to say, if we apply two functions in sequence as in g[f[x]], then we
can think of it as one single function that is a composition of f and
g=2E In math notation, it is often denoted as (g=E2=88=98f). For example,
g[f[x]]=E2=86=92y is the same as (g=E2=88=98f)[x]=E2=86=92y. In our pseudo-=
code, the
function composition takes any number of arguments, and returns a
single function of their composition.

When we define a subroutine, for example:
subroutine f(n) {return n*n}

the function is power of two, but the function is named f. Note here
that a function and its name are two different concepts. In
well-thought-out languages, defining a function and naming a function
are not made inseparable. In such languages, they often have a keyword
=E2=80=9Clambda=E2=80=9D that is used to define functions. Then, one can as=
sign it
a name if one so wishes. This separation of concepts made many of the
lingustic power in the above examples possible. Example:
lambda (n) {return n^2;} \\ a function
(lambda (n) {return n^2;})(5) \\ a function applied to 5.
f =3D lambda (n) {return n^2;} \\ a function is defined and named
f(5) \\ a function applied to 5.
lambda (g) {return lambda {g(f)} } \\ a function composition of
(g=E2=88=98f).

The above facilities may seem exotic to industrial programers, but it
is in this milieu of linguistic qualities the object oriented paradigm
arose, where it employees facilities of inner function (method),
assigning function to variable (instantiation), function taking
function as inputs (calling method thru object), and application of
function to expressions (applying method to data in a class).

The data-bundled-with-functions paradigm finds fitting application to
some problems. With the advent of such Objet-Oriented practice, certain
new ideas emerged. One of great consequence is the idea of inheritance.

In OOP practice computations are centered around data as entities of
self-contained boxed sets (objects). Thus, frequently one needs
slightly different boxed sets than previously defined. Copy and Pasting
existing code to define new boxed sets quickly made it unmanageable. (a
messy set of classes). With powerful lingustic evironment and
habituation, one began to write these new boxed-subroutines (classes)
by extending old subroutines (classes) in such a way that the new
subroutine contains all variables and subroutines of a base subroutine
without any of the old code appearing in the body of the subroutine.
Here is a pseudo-code illustration:
g =3D subroutine extend(f) {
new variables ...
new inner-subroutines ...
return a subroutine that also contains all stuff in subroutine f
}

Here, =E2=80=9Cextend=E2=80=9D is a function that takes another function f,=
and
returns a new function such that this new function contains all the
boxed-set things in f, but added its own. This new boxed-set subroutine
is given a name g.

In OOP parlance, this is the birth of inheritance. Here, g inherited
from that of f. f is called the base class or superclass of g. g is the
derived class or subclass of f.

In functional terms, inheritance mechanism is a function E that takes
another function f as input and returns a new function g as output,
such that g contained all enclosed members of f with new ones defined
in E. In pure OOP languages such as Java, the function E is exhibited
as a keyword =E2=80=9Cextends=E2=80=9D. For example, the above code would b=
e in
Java:
class g extends f {
new variables ...
new inner-subroutines ...
}

Here is the same example in Python, where inheritance takes the form of
a class definition with a parameter:
class g(f):
new variables ...
new inner-subroutines ...

Data are the quintessence in computation. Because in OOP all data are
embodied in classes, and wrapping a class to each and every variety of
data is unmanageable, inheritance became the central means to manage
data.

-----
to be continued tomorrow.

This is part of an installment of the article
=E2=80=9CWhat are OOP's Jargons and Complexities=E2=80=9D
by Xah Lee, 20050128. The full text is at
http://xahlee.org/Periodic_dosage_dir/t2/oop.html

=C2=A9 Copyright 2005 by Xah Lee. Verbatim duplication of the complete
article for non-profit purposes is granted.

The article is published in the following newsgroups:
comp.lang.c,comp.lang.c++,comp.lang.lisp,comp.unix.programmer
comp.lang.python,comp.lang.perl.misc,comp.lang.scheme,comp.lang.java.progra=
mmer
comp.lang.functional,comp.object,comp.software-eng,comp.software.patterns

Xah
xah@xahlee.org
=E2=88=91 http://xahlee.org/

xah@xahlee.org

2005-06-07, 4:01 pm

The Rise of Class Hierarchy

Because of psychological push for purity, in Java there are no longer
plain subroutines. Everything is a method of some class. Standard
functions like opening a file, square root a number, for loop thru a
list, if else branching statements, or simple arithmetic operations...
must now somehow become a method of some class. In this way, coupled
with the all-important need to manage data with inheritance, the OOP
Class Hierarchy is born.

Basic data types such as now the various classes of numbers, are now
grouped into a Number class hierarchy, each class having their own set
of methods. The characters, string or other data types, are lumped into
one hierarchy class of data types. Many types of lists (variously known
as arrays, vectors, lists, hashes...), are lumped into a one hierarchy,
with each Classe node having its own set methods as appropriate. Math
functions, are lumped into some math class hierarchy.

Now suppose the plus operation +, where does it go? Should it become
methods of the various classes under Number headings, or should it be
methods of the Math class set? Each language deals with these issues
differently. As a example, see this page for the hierarchy of Java's
core language classes:
http://java.sun.com/j2se/1.4.2/docs...ckage-tree.html
(local copy)

OOP being inherently complex exacerbated by marketing propaganda, and
the inheritance and hierarchy concept is so entangled in OOP, sometimes
OOP is erroneously thought of as languages with a hierarchy. (there are
now also so-called Object-Oriented databases that ride the fad of
=E2=80=9Call data are trees=E2=80=9D ...)

Normally in a program, when we want to do some operation we just call
the subroutine on some data. Such as
open(this_file)
square(4)

But now with the pure OOP style, there can no longer be just a number
or this_file path, because everything now must be a Object. So, the
"this_file", usually being just a string representing the path to a
file on the disk, is now some "file object". Initiated by something
like
this_file =3D new File("path to file");

where this file class has a bunch of methods such as reading or writing
to it.

see this page for the complexity of the IO tree
http://java.sun.com/j2se/1.4.2/docs...ckage-tree.html
(local copy)

see this page for the documentation of the File class itself, along
with its 40 or so methods and other things.
http://java.sun.com/j2se/1.4.2/docs...va/io/File.html (local copy)

-------
to be continued...

This is part of an installment of the article
=E2=80=9CWhat are OOP's Jargons and Complexities=E2=80=9D
by Xah Lee, 20050128. The full text is at
http://xahlee.org/Periodic_dosage_dir/t2/oop.html

=C2=A9 Copyright 2005 by Xah Lee. Verbatim duplication of the complete
article for non-profit purposes is granted.

The article is published in the following newsgroups:
comp.lang.c,comp.lang.c++,comp.lang.lisp,comp.unix.programmer
comp.lang.python,comp.lang.perl.misc,comp.lang.scheme,comp.lang.java.progra=
mmer
comp.lang.functional,comp.object,comp.software-eng,comp.software.patterns

Xah
xah@xahlee.org
=E2=88=91 http://xahlee.org/

Sponsored Links