Introduction to Eiffel

Dan introduces us to the Eiffel language, a fairly new Object-Oriented language designed to streamline the software engineeering process.

Suppose you need a class to manipulate a structured collection of objects—an array of INSECTs, a parse tree, a hashed list of sales prospects, or some such thing?

Some object-oriented languages furnish a general approach. You construct a template for, say, a LINKED_LIST or an ARRAY. You then use this template with some arguments indicating the classes to be used in constructing the particular LINKED_LIST or whatever.

In Eiffel, this capability is called genericity, and the templates are generic classes. As usual, this is done in a way that does the job and yet is so simple, it seems effortless.

Suppose you are writing an ant hill. First you need some ants.

class ANT
     inherit INSECT
     -- A basic ant.  It has features to crawl,
     -- forage, dig, tend the young, and so on.

     inherit ANT
       -- Redefine some things.
       -- These chew on your house and your apple
       -- tree.

class ARMY_ANT
     inherit ANT
       -- These are always on the go.
       -- You hope they don't stop by your place
       -- for dinner.

Now you are ready for ant hills. Let us suppose you already have some class that models insect societies. Its header might look like this


which indicates that an INSECT_SOCIETY may be formed using a parameter that conforms to INSECT. Loosely, this means any descendent INSECT will do. anthill:INSECT_SOCIETY[ANT] declares a reference to an INSECT_SOCIETY containing ants. This reference may then be attached an INSECT_SOCIETY containing CARPENTER_ANT, ARMY_ANT, or any other descendent of ANT we have defined. In fact, this allows us to reference an anthill comprising more than one kind of ant, which is convenient, as some anthills may contain more than one kind of ant.

In writing a specific container class, for example, we may wish to take advantage of things we know about insects in the features of the container class. It would never do, in such a situation, for example, to enter an object of class DOG or HAMMER into this container. The type-safe mechanism for doing this is called constrained genericity and is illustrated above in the header line for class INSECT_SOCIETY.


The Eiffel programming language offers power, simplicity, strong type checking, and numerous other amenities. With an open specification for both the language and the kernel libraries, and support from multiple vendors, Eiffel now stands poised to take off.

According to one vendor, most interest lately has come from people who are turning to Eiffel having used C++ for some years and who have become convinced that the training costs and the complexity of that language are not justified by the features provided.

The more adventurous among us who have a thirst to tackle an object-oriented programming language unhindered by excess baggage from the past ways of doing things may wish to further explore this language.

In my next article, I'll write more about ISE Eiffel and the compiler and tools from Tower Technology of Austin, Texas. I'll also offer a few thoughts about how to get started with this language.

Dan Wilder has been employed as a software engineer since 1975. Dan resides in Seattle, where he divides his time between work, family, and a home Linux system. Any time left is spent ignoring the moss collection his neighbors think he calls a lawn. He can be reached via e-mail as


Geek Guide
The DevOps Toolbox

Tools and Technologies for Scale and Reliability
by Linux Journal Editor Bill Childers

Get your free copy today

Sponsored by IBM

8 Signs You're Beyond Cron

Scheduling Crontabs With an Enterprise Scheduler
On Demand
Moderated by Linux Journal Contributor Mike Diehl

Sign up and watch now

Sponsored by Skybot