We are sure that most of the terms explained here are well known, so don't worry if something is explained that you are already familiar with. On the other hand, we probably forgot to explain some things that you don't know. In this case, please notify us. We like to enhance our documentation!
A buzzword meaning all the compilation information related to a project or a library. It contains almost all the information the compiler has about the classes included in a project. At the first compilation the compiler builds an internal data structure containing the information about all classes used in the project, and the relations between these classes. This information is used by the compiler and is also provided to the workbench to control the browser. When a project is closed (for example by exiting the workbench) the context is stored.
The next time the project is opened the context can be loaded as a whole - this is much faster than reading all the classes and re-creating the context. This is also one reason why recompilation is much faster than a new compilation.
Things become more interesting when the workbench is involved. In this case loading and storing only happens once - loading at startup (not everything at once but in small increments) and storing upon exit. During a workbench session, everything is instantly available.
The size of the context is proportional to the size of a project. So, big projects need more RAM.
Any class can have one or more creation procedures. One of these procedures must be called whenever an object of this class is created. Creation procedures are ordinary procedures that are mentioned in the creation clause of the class.
A root class must have at least one creation procedure.
An Eiffel System Description file describes the project options and the project components (two more nice buzzwords ;-). This file has the suffix .esd and is stored in the project directory. The ESD file can be changed with a text editor or from the options menu in the workbench.
The format is described in a separate document. Creating a new .esd file is rather simple.
Everything that can be compiled is either a library or a project. So, any program is a project. Each project is stored in a unique folder, the project folder. No project folder can store more than one project. The folder usually contains:
Each project has some compilation options. They are stored in the .esd file. You may find it convenient to use the workbench to set these options.
The project directory and the libraries used in the project comprise the project context. The libraries used in the project can be set from the workbench or "manually" by editing the .esd file.
A collection of Eiffel classes which can be used by many projects. They are stored in the library folder and can be precompiled to native code (even in the lite version!). Such precompiled libraries can be used without any compilation in projects. In case of name clashes it is possible to mount or unmount libraries.
Sometimes it may be useful to remove a project or a library from the repository and to reload it later. We call this mount and unmount.
The place where something is stored in the computer - sometimes also called directory or subdirectory. We use folders to store information which belongs together - for example all classes of a project. It is possible to combine classes from many folders into one library or one project.
This is an important Eiffel concept - it is the class describing the first object to be created at runtime. As you might guess, this object cannot be created in an Eiffel program with a creation instruction ("!!"). Therefore it is necessary to specify outside of the program the name of this class and also the creation procedure to be used. In other words, one can call the pair root class and creation procedure the main program in the classical sense.
The root class and creation procedure are specified in the .esd file.
One very interesting feature of a Visual Eiffel project is that the compiler stores all information collected in a compilation step, and can reuse much of this information in the next compilation step. This speeds up compilation dramatically. The compiler detects changes to the source code and decides which classes must be recompiled. This decision can be done very conservatively (resulting in longer compilation times) or more aggressively (with shorter compilation times but a small risk that the recompilation will fail).
The algorithm to determine which classes must be recompiled is rather complicated, and the recompilation sometimes fails (we are working to identify these situations). When it fails, it is necessary to compile the whole project again. It is not necessary to recompile the associated libraries.
This buzzword represents the set of all libraries and projects created with your Eiffel installation. It is possible to add clusters into the repository and to remove them again. We provide a special page about the repository.