What's all the HOOPLA about? Programming jargon, you neophyte

By Wayne V. Herbert (From the Peer to Peer section of InfoWorld, 10/4/93)

Object-oriented programming is confusing. Even the definition of
object-oriented programming is open to many different interpretations. This
sad state of affairs reduces productivity and hinders the spread of this
exciting new technology.

All is not lost, though. With the announcement of HOOPLA (Hopelessly Obtuse
Object Programming Language with Attachements), the ultimate in
object-oriented development environments is available to even the most
skeptical programmer. HOOPLA not only embodies all the paradigms and
concepts of today's object-oriented languages, it provides many extensions
and techniques to further obfuscate the art and science of computer
programming.

The list of HOOPLA's benefits is nearly endless, but here are a few that
will keep trainers busy for years to come.

* Metamorphism. Expanding on the concept of polymorphism, HOOPLA's
powerful artificial intelligence automatically changes class libraries
and objects while you are asleep. Based on the few lines of code you
write today, HOOPLA "knows" that sooner or later you will have to code
the details of the module and does it for you. Plus, the changes are
hidden, ensuring that class ancestor code remains a mystery.

* Two-Parent Inheritance (TPI). Taking a cue from biology, TPI combines
classes from separate hierarchies and subjects them to a "survival of
the fittest" test. Any classes that don't cause unrecoverable
application errors are incorporated as new derived classes.

* Dynamic Bondage and Discipline. Allows programmers to write a generic
routine and use it over and over again, with unpredictable results.
Through the discipline module, however, programmers can be assured
instructions will be obeyed and unruly objects won't make the same
mistake again.

* Object Insistence. Taking persistent objects one step further,
insistent objects finally solve the most dreaded of programming
errors: the accidental deletion of code. Insistent objects don't go
away even when you want them to.

* Graphical Object-Oriented Programming (GOOP). Recognizing that some of
the most brilliant ideas have resulted from doodles, GOOP provides the
programmer with a library (a Dynamic Link Library, actually) of
thousands of whirlygigs, curlicues, doodads, and whooziwhatzis that
can be linked together using toolbar functions. When complete, the
programmer simply clicks on the "invent" icon (a lightbulb) and reams
of notation code are automatically generated. For the advanced
programmer, this module comes with the Graphical Library Object Parser
(GLOP).

HOOPLA goes beyond merely supporting and enhancing the standard
object-oriented buzzwords. In addition to providing extensible code, HOOPLA
supports existential code, allowing programmers to write programs that are
out of this world. HOOPLA code is reusable, recyclable, refillable, and
biodegradable, meeting all future government standards for nonpolluting
code.

Although object databases are relatively new, HOOPLA supports existing
standards and sets the standards for future object- oriented database
development with such robust constructs as ALIEN (Awfully Large Inclusions
of Extra Nulls). Such powerful class types require a whole new approach to
information retrieval, and HOOPLA stands up to the task with SMOKE
(Single/Multiple Object Kwery and Extraction) and MIRROR (Massively
Inefficient Random Retrieval of Object Resources).

HOOPLA is slated to sell for $895. During the introductory period, however,
HOOPLA will be available as a competitive upgrade for $6.95 if the title
page from any Nancy Drew mystery is included with the order. A HOOPLA
representative said, "It is appropriate. We want to take the mystery out of
object- oriented programming."
---------------------------------------------------------------------------