Main features of Eiffel

The main features of Eiffel are:

- clean object orientation with multiple inheritance

- design by contract

- elegant expressive syntax

- automatic memory management

- generics

- uniform type system with type safety (exept catcalls)

These features were unique at the time Eiffel was invented (some 25 years ago). Since that time a lot has happened in the world of programming languages. C++, java, C# and scala (just to mention the most prominent and successful ones) have entered the scene.

The most recent one -- scala -- has nearly all key features of Eiffel except design by contract. But scala in its current form offers much more than Eiffel. It has type inference, strong support for functional programming, support for small scripts and large programs, complete type safety, concurrency etc. In short, Eiffel has lost the lead.

Looking back the past 25 years since its invention, some improvements have been made: Syntax improvements, agents, non conforming inheritance, void safety etc. But even if one tries to see it in a positive manner, this is not that much.

But Eiffel has still potential. In order to gain impact, an effort is needed to modernize Eiffel. The key feature design by contract is still unreached by other languages and opens the way for static verification. But the other key features supported by other languages must be introduced into Eiffel as well (a programmer using the advantages of type inference and functional programming of scala will never switch to Eiffel unless Eiffel offers at least the same and some other interesting features).

Vision for a modern Eiffel

- Much more support for functional programming (Assertions can use only the functional sublanguage of Eiffel. In order to make assertions more powerful, functional programming has to be supported significantly better).

- Static verification of assertions

- Static verification of void safety (i.e. real void safety)

- Type safety: There shall be no possibility to generate type errors at runtime (catcalls).

- Concurrency has to be integrated into the language. Scoop in its current form is not sufficient (too simplistic). Static verification needs to be able to prove that a program is free of deadlocks.

- Block scoping of variables: If a variable is only needed within a certain block of a routine, it shall be declared, initialized and used only there.

- support for immutable strings and immutable types

- Type inference: Redundant type annotations shall not be necessary

- Close the gap between scripting languages and compiled languages.

- Community driven (i.e. free and open)