[[Property:title|Introducing EiffelStudio]]
[[Property:weight|2]]
[[Property:uuid|acf5433b-14e9-1d21-c8cf-997db7821550]]
EiffelStudio is the central tool of Eiffel Software's implementation of Eiffel, letting you design, develop, debug, document, measure, maintain, test, revise and expand systems using the full power of object technology and Design by Contract™. 

This guided tour introduces the essential properties of EiffelStudio. It will take you through a tour of the environment, using a pre-existing example system.

==What will I achieve?==

Although it skips many specific or advanced facilities, this Tour will help you quickly become familiar with the way you can use the environment for your work. After reading it you will know the basics of working with EiffelStudio:
* '''Starting a project''' and '''retrieving an existing project'''.
* '''Entering new software elements''' -- clusters, classes and features.
* '''Compiling''' your software.
* '''Making changes''' and '''recompiling''' them immediately using the Melting Ice Technology™. 
* Displaying a '''graphical representation''' of your software elements, and '''modifying''' the software through the graphical views (as well as through its text).
* Producing extensive '''documentation''' of your system, textual or graphical, under many different formats such as HTML, RTF, Postscript, XMI (for example Rational Rose) and others.
* '''Browsing''' through simple or complex software systems, to find out their various components, properties and relationships.
* '''Measuring''' quantitative properties of the software, by applying metrics predefined in EiffelStudio as well as new ones that you define.
* '''Executing''' a compiled system.
* Controlling execution through the '''debugging''' mechanisms of EiffelStudio.
* Creating an effective '''test suite''', with the automated assistance of '''AutoTest'''
* Add '''licensing''' text to your classes automatically.

==About the scope of EiffelStudio==

The most important property to keep in mind as you are discovering EiffelStudio is that it is neither just a "programming environment" nor just a "CASE tool" (Computer-Aided Software Engineering) for analysis and design. It encompasses both of these functions and many others. Most system builders today are used to a dichotomy between the high end and the low end:
* At the analysis and design levels, graphical tools help you clarify your thinking about the system, interacting with customers and end users, and devise high-level system architectures, usually in diagrammatic form.
* At the low end, programming tools help you edit, compile and debug your programs.

Keeping these tools separate is, however, detrimental to the quality of the software process and the resulting products. If they are in the hands of different teams, communication problems may arise, leading to discrepancies between need and realization; this can be a source of bugs or even project failure. If it's the same people using tools of both kinds, they have to keep switching notations, tools and modes of thinking. The use of different frameworks at both ends makes it difficult to keep the high-level model and the implementation consistent; too often, a change decided at the implementation level is not reflected back in the higher model. After a while, the system gets into the state of disorder and inconsistency that good tools are precisely meant to avoid.

EiffelStudio, in line with the principles of <span>seamless development</span> and <span>reversibility</span> of the Eiffel method, removes the gap by providing a single set of tools that accompany you throughout a project, from the most high-level initial stages to the most low-level aspects of implementation and maintenance.

This generality is reflected throughout the environment by, for example, the dual use of text and graphics. As another example, you should think of the EiffelStudio <span>compiler</span>, not just as a tool for executing Eiffel software in its final form, but also, thanks to its extensive <span>validity checking</span> facilities, as a design consistency tool that performs many verifications commonly associated with CASE tools.

Depending on your project needs, you may take advantage of EiffelStudio's versatility to address specific purposes:
* You may use EiffelStudio as a programming environment, with advanced tools for compiling, browsing and debugging.
* Some people use EiffelStudio as a <span>modeling</span> tool only, building system descriptions consisting only of <span>deferred</span> (abstract) classes with no implementation, and relying on the Diagram Tool to build, present and discuss these descriptions through graphical views.
* You may use EiffelStudio in both capacities, taking advantage of the seamlessness between all the affected phases.

==Learning by doing==

If you have access to EiffelStudio as you read this Tour, the most effective technique is to execute all the suggested operations as you read about them.

Please execute user actions, such as clicking, only when asked to do so.

==What should I already know?==

This Tour assumes very little about what you know and what you don't.

It does assume that you can do simple manipulations on your platform of choice, such as: on Windows, finding and drag-and-dropping folders and files in the Windows Explorer; on Unix, changing to a certain directory ( <code>cd</code> ) and listing the files of a directory ( <code>ls</code> ).

The more you already know about object technology and object-oriented environments, the better. But remember, if you have used other environments before, keep a fresh outlook; EiffelStudio <span>is</span> different, and it may take a while before you fully understand why it does some things in a certain way.

==A note on platform differences==

EiffelStudio is one of the most portable environments in the industry, running in an almost identical fashion on Windows, on the new Microsoft .NET environment, on many variants of Unix, on Linux, on OpenVMS.

Once an EiffelStudio session has been started, you can largely forget about the operating system. But a few operations -- mostly at the beginning, to launch EiffelStudio -- require platform-dependent mechanisms: starting a program, traversing the file structure, selecting a file. These cases will be marked accordingly below.

Windows users should particularly note the following two conventions of terminology:
* Operating systems store files into hierarchically nested structures called <span>folders</span> or <span>directories</span>. Although "folder" is the more common term for Windows, we will mostly speak of "directories". It's exactly the same thing. 
* A file has a full <span>path name</span>, used to describe how to reach it from the root of its file system, as in <code>c:\d1\d2\f</code> . This example uses the Windows notation, which separates successive components of a path name by a backward slash character <code>\</code> . On Unix and Linux, the separator is a forward slash <code>/</code> , as in <code>/d1/d2/f</code> ; this is also the convention on the Internet for denoting addresses (URLs). Most file names in this manual appear in this Unix/Internet style. On Windows you will normally have to use the backslash convention, although EiffelStudio also accepts forward slashes. In any case you must be consistent: don't mix backward and forward slashes in the same path name. Also note that some names, such as those of object files to be linked with your system, will be passed to outside tools -- C compilers, loaders -- that may not accept the forward slash. 

OpenVMS users may similarly use either the Unix convention or the specific OpenVMS path naming convention.

If you are a one-platform person, just ignore, for the next few pages, all references to any platform other than your heart's favorite. They will quickly go away.

==What should I have done first?==

To run the example you must have installed EiffelStudio and set up the environment. Check in particular the following:
* On Windows, you must have run the installation procedure; it will have put EiffelStudio in the Programs section of the start menu, subsection "EiffelStudio version", where version is the version number, e.g. 6.0.
* The environment variable <code> ISE_EIFFEL </code> must be set to the installation directory, and the environment variable <code>ISE_PLATFORM</code> to the platform. On Windows this is taken care of automatically by the installation procedure, but on Unix/Linux and OpenVMS you must update your path and environment manually. Throughout this discussion the notations <code>$ISE_EIFFEL</code> and <code>$ISE_PLATFORM</code> will refer to the values of these variables -- the installation directory, and the platform. (The Windows notation would be <code>%ISE_EIFFEL%</code> and <code>%ISE_PLATFORM%</code>.) 
* On Unix/Linux and OpenVMS, your "path" must include the place where EiffelStudio executables reside. (On Windows the installation procedure takes care of this.)
* Also, the discussion assumes that as part of the installation you have included the EiffelBase library, in precompiled form. EiffelBase is automatically included if you have installed another precompiled library, such as WEL, the Windows Eiffel Library. The installation procedure takes care of precompiling EiffelBase.

==Locating the example==

Please take a moment to locate the example files on your installation. They all appear in the following directory, part of the Eiffel delivery:
<code>$ISE_EIFFEL/examples/studio/tour</code>

(Windows users: remember that instead of the slash <code>/</code> your platform uses a backslash <code>\</code> . OpenVMS users: this is to be replaced by the OpenVMS path naming conventions.) 


{{seealso|For a quick introduction to EiffelStudio, see the online EiffelStudio presentation available on the Eiffel Software [http://www.eiffel.com/developers/presentations/ developers' presentations web page].}}