EiffelStudio includes a combination of tools integrated under a single user interface: compiler, interpreter, debugger, browser, metrics tool, profiler, diagram tool. The user interface rests on a number of specific UI paradigms, in particular "pick-and-drop" for effective browsing.
Status, license and community process
The Eiffel community actively participates in its development; a list of open projects is available from the Origo site, hosted at ETH Zurich (see "external links"), together with the source code base for check-out, discussion forums etc.
As of July 2013 the last released version was 7.3. Successive beta releases are regularly available.
EiffelStudio uses a specific compilation technology known as Melting Ice (claimed by Eiffel Software as a trademark) which integrates compilation proper with interpretation of the elements changed since the last compilation, for very fast turnaround (recompilation time proportional to the size of the change, not the size of the overall program). Although such "melted" programs can be delivered, the common practice is to perform a "finalization" step before release. Finalization is a highly optimized form of compilation, which takes longer but generates optimized executables.
The Diagram Tool of EiffelStudio provides a graphical view of software structures. It can be used in both
- Forward engineering, as a design tool for producing software from graphical descriptions.
- Reverse engineering, automatically producing graphical representations of existing program texts.
The tool guarantees integrity of changes made in either style, for full "roundtrip engineering".
User interface paradigm
EiffelStudio makes it possible to display many different views of classes and features: text view (full program text), contract view (interface only, with contracts), flat view (which includes inherited features), clients (all the classes and features that use a given class or feature), inheritance history (what happens to a feature up and down the inheritance structure) and many others.
EiffelStudio relies on an original user interface paradigm based on "development objects", "pebbles" and "holes". In the same way that object-oriented in Eiffel deal with objects during execution, developers deal with abstractions representing classes, features, breakpoints (for debugging), clusters (groups of classes) and other development objects. A development object in EiffelStudio can be selected (picked) wherever it appears in the interface, and regardless of its visual representation (name of the object, visual symbol or other).
To pick a development object it suffices to right-click on it. The cursor then changes into a special symbol or pebble corresponding to the type of the object: "bubble" (ellipse) for a class, dot for a breakpoint, cross for a feature etc. As you move the cursor a line is displayed from the original object to the current position. You can then drop the pebble into any matching place: either an icon representing a hole with the same overall shape (class hole, breakpoint hole, feature hole etc.) or a window with a compatible type. The effect of dropping a pebble into a tool is to retarget the entire tool to the development object that was "picked". For example a class tool will now display the chosen class, in whatever view (text, contract, flat etc.) was selected. This is known as the "Pick-and-Drop" paradigm.
The combination of multiple views and Pick-and-Drop makes it possible to browse quickly through complex systems, and to follow the sometimes extended transformations that features undergo under inheritance: renaming, redefinition, undefinition.
Unit and Integration Testing
EiffelStudio includes an integrated testing facility called EiffelStudio AutoTest , whereby developers may build simple to sophisticated unit and integration testing suites. The EiffelStudio AutoTest facilities enable the developer to execute and test Eiffel class code from the feature level (e.g. unit testing) to entire class systems (e.g. integration). As such, execution of this code also executes the contracts of the features and attributes executed. As such, EiffelStudio AutoTest is a means to exercising the "tests" or assumptions of the Design by Contract conditions. Therefore, unit and integration testing need not re-test through means of assertions or test oracles what has already been coded as specification in the contracts of the class text.
EiffelStudio AutoTest provides the user with three methods of test case creation.
First, for manually created tests EiffelStudio AutoTest creates a test class containing a framework for the test. The user needs only supply the test code itself.
Second, EiffelStudio AutoTest provides a method for creating a new test based on an application failure at runtime. This type of test is called extracted. If while running the target system, an unexpected failure occurs, EiffelStudio AutoTest can work from the information available in the debugger to create a new test that will reproduce the state and the calls that caused the failure. Once the problem is fixed, the extracted test can be added to the test suite as a hedge against regressions of the problem.
The third method of creating tests produces what are called generated tests. In this scenario, the user provides EiffelStudio AutoTest with the classes for which tests should be generated and some additional information used to control the test generation. The tool then begins calling routines in the target classes using randomized argument values. For every unique postcondition or class invariant violation, EiffelStudio AutoTest produces a single new test reproducing the failing call.
EiffelStudio traces its roots to the first implementation of Eiffel, by Interactive Software Engineering Inc. (predecessor of Eiffel Software), released in 1986. The origin of the current technology appears to go back to "EiffelBench", started in 1990 in connection with the design of the Eiffel 3 version of the language (as documented in Eiffel: The Language, see bibliography). EiffelBench was renamed "EiffelStudio" around 2001; this is also the time when the environment went beyond its Unix origins to target Windows and other platforms.
Major releases since 2001, and some of the new features for each, have been:
- 5.0, July 2001: first version to be "EiffelStudio" proper; integration of previous "EiffelCase" tool for graphical design with EiffelBench, in the form of EiffelStudio's Diagram Tool)
- 5.1, December 2001: first version to support .NET (press release (PDF)). It was called "Eiffel#" before releasing .
- 5.2, November 2002: new EiffelBuild for GUI design, extended debugging, new mechanisms for C and C++ integration, better roundtripping facilities for the Diagram Tool (press release).
- 5.3, March 2003: Incremental compiler technology available for Eiffel .NET. Eiffel2Java Java interface, EiffelStore (relational database interface) now available for .NET, first Mac OS version, performance enhancements (press release).
- 5.4, November 2003: new conversion mechanism, major run-time performance improvements (in particular for agents), major compilation speed improvements, improved support for multithreading, major EiffelBuild enhancements, first support for new mechanisms as defined by the ECMA Eiffel committee, support for preconditions and postconditions in external (e.g. C) routines, transparent way to call overloaded .NET routines from Eiffel (press release).
- 5.5, September 2004: docking, improved debugger, new ECMA language features (press release).
- 5.6, August 2005: enhanced diagram tool (UML support, force-directed graphs, better roundtripping), new EiffelCOM wizard for generation of Microsoft COM components, better class completion, faster .NET code generation (press release).
- 5.7, October 2006: ISO/ECMA Eiffel addition (inline agents, new "expanded" semantics, named tuples, Unicode support), refactoring facilities, new way to configure a project system, metrics (press release).
- 6.0, June 2007: ISO/ECMA Eiffel addition (multiple constraint genericity, octal and binary notation for integers), new tabbed editor, new docking facilities to let user define their workspace, context menu is available in addition of pick and drop, dependency tool (press release).
- 6.1, November 2007: (press release).
- 6.2, May 2008: (press release).
- 6.3, December 2008: (press release).
- 6.4, June 2009: (press release).
- 6.5, November 2009: (press release).
- 6.6, May 2010: (press release).
- 6.7, November 2010: (press release).
- 6.8, May 2011. Includes the first implementation of facilities supporting SCOOP, Simple Concurrent Object-Oriented Programming. (press release).
- 7.0, November 2011. Includes performance and functional enhancements to the SCOOP parallel development facility, GUI library and tool support for ribbon interface structures, improved support for void-safe software development, and many other improvements.
- 7.1, June 2012. Includes SCOOP processor garbage collection. Multiple improvements to Eiffel Information System linking application code to appropriate external resources such as requirements documents.
- 7.2, February 2013.
- 7.3, July 2013.
- 13.11, December 2013. This release marks the beginning of using a new version numbering scheme. (Release note)
Inspector Eiffel is a Rule-based static code analysis tool which operates both from an embedded mode in Eiffel Studio and from command line. It utilizes the abstract syntax tree (AST) produced by the Eiffel compiler and then generates a control flow graph (CFG), which is computed by a module of code in the tool. The CFG and AST are then visited by a number of defined rules. Violations of any rule is reported to the user as a list of Error, Warning, Suggestion, and Hint items. Each rule violation reports precisely which rule was violated
- Eiffel Software's home page at eiffel.com
- For open-source contributors: Eiffel home page at ETH Zurich
- EiffelStudio at SourceForge
- Origo site
- Eiffel Software: EiffelStudio manual. Online at http://docs.eiffel.com/
- Bertrand Meyer: Eiffel: The Language, Prentice Hall, 1991 (second revised printing, 1992).
- Bertrand Meyer.: An Object-Oriented Environment: Principles and Applications, Prentice Hall. 1995 (describes the principles underlying the original EiffelBench).
- Kim Waldén and Jean-Marc Nerson: Seamless Object-Oriented Software Architecture, Prentice Hall, 1995 (contains a description of the BON method and notation).