Why Eiffel?
 
 
Eiffel is the most complete object-oriented language around. It is a simple complex language. Isn’t that an oxymoron? Yes, but in Eiffel’s case the simplicity of learning the language itself might conclude some to believe it is only a basic language, or as some would disparagingly say a “teaching language”. This is far from the truth, since Eiffel supports the most sophisticated software development methods. It is a complete philosophy of programming - that philosophy getting out of the way so that you can program. It minimizes the importance of things that are not so important in software development and put the things that are important at the top – in other words everything is put in its place – other languages are just used for coding.
 
For an introduction see Into Eiffel
Eiffel Wikipedia
 
That said, here is a list of Eiffel features:
  1. •multiple inheritance (implementation, not just interface) done in an elegant way – break your common functionality into small utility classes to be inherited and used by others;
  2. •comprehensive libraries for all common data structures and algorithms (with simple and consistent naming conventions);
  3. •garbage collection (on OS X integrated with Cocoa programming - no more reference counting woes!) and it’s an efficient implementation;
  4. •design by contract (DbC) including preconditions, postconditions, class invariants, with integrated exception handling;
  5. •trusted component initiative (Eiffel had this term first!) of building trustworthy libraries using DbC;
  6. •genericity – there is no need of typecasting;
  7. •constrained genericity – a class can invoke features on a generic type without typecast and potential runtime class cast exceptions;
  8. •covariance – types of features and arguments can be made more specific in subclasses;
  9. •anchored types – features can be typed 'like' another feature or enclosing class, so that you only have to make a change in one type in a subclass to affect a whole lot of things);
  10. •principles of OO programming as outlined in Bertrand Meyer's must-read OO classic Object-oriented Software Construction;
  11. •project lifecycle – full support from design to implementation to testing to maintenance to enhancing without the typical departmental barriers in usual software development techniques, where programmers are involved go-to-wo in an integrated design and implementation approach (just like Apple projects!);
  12. •industry best practice (an abused term) – not just what's flavor of the month or fashionable with Dogbert consultants and pointy-haired managers;
  13. •test-driven development (TDD) – Eiffel integrates TDD in a way no other language does using design by contract. In TDD tests are written first separately, but in Eiffel tests are written as you specify and integrated with the code, not separately. With Eiffel’s preconditions and postconditions you are testing both the calling module and the called module. This is sometimes known as behaviour-driven development. You will still need unit tests to exercise your software, but the tests for success are put in the ensures clause, acting as documentation for your software contract;
  14. •fine-grained exports allowing related classes to export to each other, far beyond public, protected, private, and package views;
  15. •elegant and readable syntax without clutter required in other languages (eg., no superfluous begins, less nested parentheses, or empty () to tell compiler this is a function or function call, no ** pointer dereferencing, no typecasts), no need for semicolons or stops as statement terminators or separators;
  16. •simplicity of scripting language with ease of simple syntax like Python and Ruby, but Eiffel is compiled, not interpreted for speed;
  17. •sophisticated multi-pass compiler – the advantage of this is that the clutter of forward declarations as in C and C++ is avoided, as in Java;
  18. •no need for maintenance of imports or #includes in source code – all this is maintained in a single central repository;
  19. •no need to maintain separate interface (.h, etc) files or the need of cluttering up every source file with #includes, or imports. Class interface documents can be generated automatically by the flat and short tools (like Javadoc);
  20. •dependency analysis – since Eiffel is straightforward, sophisticated dependency analysis is done by the compiler without the need of maintaining 'make' files;
  21. •style conventions were developed along with the syntax for readability and removing most of the need for obtrusive departmental 'programming and style guides';
  22. •simplicity and elegant design with one good way of doing most things without the intersection of features of most languages where bugs arise because features were used together in ways unthought of before, general lack of 'gotchas' present in other languages – further removing most of the need for obtrusive departmental 'programming and style guides' to avoid common traps;
  23. •uniform access – functions, variables, and constants are invoked the same way, and interchangeable, so programmers do not have to clutter classes with superfluous 'get' functions);
  24. •refactoring – has become the latest buzz in the industry. Eiffel is perhaps the best language in the industry in its support of refactoring. Firstly, you will actually need to refactor less – it’s harder to write messy code in Eiffel in the first place. But if you do, or have inherited a system from elsewhere, Eiffel enables wide-scale rejigging of software, and once you build, Eiffel’s powerful validity checking mechanism will make sure that you have done the refactoring right.
  25. •speed, speed, speed – Eiffel generates native code, not virtual machine code, strong typing ensures most efficient code is produced, removing the need for many run-time checks, dispatch tables resolve directly, not by linear search as with untyped languages;
  26. •speed, speed, speed – no conversions of Numeric object types to built-in numbers – the compiler automatically wraps efficient low-level numbers in high-level objects, eg., an int is accessed through the INTEGER class, but otherwise you use INTEGERs just as you would an int without conversion;
  27. •speed, speed, speed – only one BOOLEAN class, no Boolean/boolean conversions;
  28. •Macintosh libraries for Cocoa and Carbon programming;
  29. •Xcode features to generate best code for Macintosh;
  30. •high-level debugging and tracing;
  31. •cross-platform programming;
  32. •easy external access to low-level routines in C and Objective-C.