"Assembly of Classes in Eiffel". An
Ace
file specifies a system consisting of a
universe,
a
root
class
,
and a root creation procedure. You will need an Ace to compile any system.
The universe is defined by a list of
clusters.
An Ace associates a directory with each cluster; the classes of the cluster are
the contents of all files in the directory with a name of the form
name.e, with the
exception
of any file listed in an exclude clause for the cluster and complemented by any
file listed in an include clause.
To specify a system you will also need to state the root class (which must
be one of the classes of the universe) and the root creation procedure (which
must be one of the creation procedures of the root class).
The
template
opened for editing in iss-build currently having the focus.
All tools of iss-build are
targeted to the
active
dialog
and display the
template
type
of the active dialog in their title bars.
The element last selected in the
active
dialog
(even when it belongs to a group of selected elements). All functions of the
Edit menu, as well as the corresponding toolbar buttons, affect only the
active element
of the active dialog. The currently active element is also highlighted in
the
Navigator,
and only this element can be edited with the Navigator.
The
template
currently selected in the
Component
Gallery
.
The
active
template
determines the type of element that will be inserted into a dialog when a free
position is clicked on.
In a graph, the node itself, its parents, and
recursively all
ancestors
of its parents. For example, in an
inheritance
hierarchy, the ancestors of class A would be class A itself, all
classes B1 to Bn inherited by A, and
recursively all ancestors of B1 to Bn, up
to ANY, the mother of all classes.
The reverse term is
descendant.
Event explicitly generated by the application.
Such events are handled in much the same way as MS WINDOWS events
and can be used to broadcast information, state changes, etc., to the different
parts of an application.
Denotes routine pre- and
postconditions
and class
invariants.
Assertions
play a central part in the Eiffel method for building reliable
object-oriented
software. They serve to make explicit the assumptions on which programmers rely
when they write software elements that they believe are correct. Writing
assertions, in particular
preconditions
and postconditions, amounts to spelling out the terms of the contract
which governs the relationship between a routine and its callers. The
precondition binds the callers; the postcondition binds the routine.
The underlying theory of Design by
Contract, the centerpiece of the Eiffel method, views software construction
as based on contracts between clients (callers) and suppliers (routines),
relying on mutual obligations and benefits made explicit by the assertions.
One of three pages of the iss-buildInspector
Tool; provides access to the attribute values of the element currently selected
in the
active dialog.
If more than one element is selected, the values of attributes common to all
selected elements are accessible.
("Business Object Notation") The conceptual basis
for iss-case, which is
completely described in the book "Seamless
Object-Oriented
Software Architecture" by Kim Waldén and Jean-Marc Nerson, Prentice
Hall, 1995. In contrast with most existing software methods,
BON
accepts that the path from analysis through design to implementation is not
one-way, and helps developers integrate implementation additions and changes
back into the high-level model, for consistency and traceability.
Means exploring the various components of a system
to find out quickly about their properties and their relations. The
environment's
browsing
capabilities rely on all tools of iss-base, especially the System,
Class and
Feature
tools
.
The
Class
Tool
provides the most important functionality: a wide range of formats, which give
access to all the information about the context of a class - features of
various kinds,
ancestors,
descendants,
clients, suppliers. The formats of Feature Tools provide important
complementary mechanisms.
One of two complementary modes for a dialog opened
in iss-build. When creating
or opening a dialog you are automatically in
Buildtime
mode
.
The Buildtime mode ensures that you can edit all elements of the
active
dialog
.
Runtime
mode
is the complementary mode.
For features this is a nice and easy way to obtain
the context of a feature: You select the feature at a place where its name
appears and drop the corresponding pebble into a Class
hole;
then you can browse over the
ancestors,
clients,
descendants,
and so on, of the class where the feature was originally selected.
Clicking on the Class hole of the
Project
Tool
produces a void (non-targeted) Class Tool.
Serves to create and modify classes. It is also
essential for
browsing
and filtering class text, that is, formatting according to the conventions of
some arbitrary external tool. The
Class
Tool
offers essential functionality: a wide range of formats, which provide access
to all the information concerning the context of a class - features of various
kinds,
ancestors,
descendants,
clients, suppliers.
To target or retarget the current Class Tool to a
class or feature, you can
drag-and-drop
the occurrence of its name into the Class
hole
at the top left corner of the tool's window. Since the entire Class Tool window
is like a big class hole, you can also drag-and-drop the name anywhere inside
it. If the name already appears in the class tool, you will not need to drag at
all. Just
right-click
twice on the name, and the Class Tool retargets itself to this object.
A model of computing where a number of software
systems, the clients, may require general-purpose services provided by other
systems, the servers. Clients and servers run concurrently, on the same machine
or more generally, on different machines connected through a
network.
Typically, the clients are systems, for example,
systems providing useful facilities for human users; the servers take care of
operations that clients could not perform on their own (or would perform less
efficiently) and also operations that are common to several clients.
The
client-server
relation is usually many-to-many: Each client application, in the course of
performing its duties, may successively require services from different
servers; each server may cater to different clients. This second aspect is
particularly important; it allows a single server to communicate with as many
clients as appropriate.
In network-style client-server communication, the mechanism will be
dissymmetric, reflecting the possibility of a single server catering to many
clients. The clients will state both the machine identification of their
intended server and the port on which they will talk to that server. The
server, however, will only specify the port; this means that it makes itself
available to any client that cares to talk to it on that port. This provides
some of the essential flexibility of client-server communication, where only
one of the partners needs to state beforehand whom it wants to talk to.
Because communication is bidirectional, the distinction between client and
server is not between who sends and who receives. The client is the party that
initiates the communication; the server is the party which stands ready to
accept the communication.
A set of closely related classes, all with
different names. The iss-bench environment associates each
cluster
to a certain directory of the file system, which contains all the class files
of the given cluster. Clusters are used in
Ace
files to define the system
universe:
each entry starts with the cluster name, which is followed by a colon and the
name of the associated directory enclosed in double quotes.
The Cluster format of the
System
Tool
lists all the clusters of a system and underneath each cluster listing the
classes contained in that cluster.
Represents the encapsulation of a specific
command. A
command
class
inherits TUNE_COMMAND (the common
ancestor
of all classes implementing
command
objects
)
and implements the feature execute.
An object registered at the
TUNE
manager
for creating a certain type of command. Upon request a
command
creator
will provide a
command
object
of the specified type. A command creator has to conform to TUNE_COMMAND_CREATOR.
Represents the technique of encapsulating actions
in
command
classes
,
i.e., classes conforming to TUNE_COMMAND. This technique is central to the
TUNE
system.
A common point of reference for establishing a
connection between two systems communicating through
sockets.
In single-machine mode the common address will simply be the full name of a
file, including path. This file must not exist prior to the communication; it
will be created by the socket mechanisms and then removed.
For the
network
style of communication, to define a common address, we may use two elements of
information: the name of a machine, and the indication of a port on that
machine. The port will be identified by an integer. The machine may be
identified in either of two ways: its host name (the name assigned to
the machine when the operating system was first installed on it) or its
Internet address.
Object of a type conforming to TUNE_COMPOSITE that is used to manage other
TUNE
objects
.
In this relationship the
composite
is called the parent and the other objects its
children.
A
resource
file
containing information for configuring an application. For example, iss-build reads information from a
configuration file
named build.trf at startup time for its internal configuration.
Event generated by the iss-build run-time system when
instantiating objects. An event with
event
ID
construction is emitted at the onset of object instantiation. In case of
a
composite,
an event with event ID chicon is emitted after a recursive instantiation
of all the children is completed.
Click
of the leftmost mouse button while holding down the CONTROL
key.
Sometimes, when the basic click is available, a
control-click
variant is also possible. Often the variant will consist of the basic operation
plus some additional effect. In other cases, the more advanced variant may be
one that restricts the effect of the operation: for example, a control-click on
one of the compilation buttons will perform the required operation without for
any C compilation that it might otherwise require.
A class whose instances are capable of creating
objects of a specific type, for example, the class PUSH_BUTTON_CREATOR for creating objects of type
UI_MS_PUSH_BUTTON. The
TUNE
manager
uses instances of classes that conform to TUNE_OBJECT_CREATOR and TUNE_COMMAND_CREATOR to create
TUNE
objects
and
TUNE
commands, respectively.
Appears on the right border of Feature, Object, and
Class
Tools
.
The
Current
button
is available when you are executing a system under iss-bench using the execution
monitoring and debugging facilities. Clicking on this button in an existing
tool will immediately retarget the tool to the current routine, object, or
class, respectively. If used outside of an execution, this tool will pop up a
non-preemptive warning panel with the message System is not
running.
A Current button is also available in the
Project
Tool
.
It retargets it to the current execution status, showing current object,
current routine, local entities and arguments, and call stack.
Mechanism of
inheritance
for stating that the implementation of a declared routine will not be supplied
in the present class but in a
descendant.
Declaring a routine r as
deferred
in a class Cexpresses that
there is no default implementation of r
in C; such
implementations will appear in eventual descendants of C. A class which has one or more deferred routines
is itself said to be deferred. A non-deferred routine or class is said to be
effective.
Stands for "Dynamic External Shared Call",
a mechanism for interfacing an Eiffel system with any outside tool as long as
the interface can be set up through DLL routines.
In a graph, the node itself, its children, and
recursively, the
descendants
of its children. For example, in an
inheritance
hierarchy, the descendants of class A would be class A itself,
all classes B1 to Bn that inherit A, and recursively all
descendants of B1 to Bn. The reverse term is
ancestor.
A command which executes different routines,
depending on the parameters it obtains. Such a
dispatch
command
is very useful for summarizing simple actions belonging to the same
domain.
Pulling the object to an application or tool that can process the object
Releasing the object
With all tools of iss-bench a
right-click
(without holding the mouse button pressed) is used to select and drop an
object, and a left-click aborts a
drag-and-drop
operation.
Once an object is selected, the mouse cursor takes on the shape of a
pebble
matching the type of the selected object. While a pebble is being dragged a
line continuously connects the pebble to the object's original position.
Dropping the pebble into a corresponding
hole
launches a new tool window.
All tools of iss-bench rely on the typed
drag-and-drop interface principle: A pebble can only be dropped into a hole
matching its type. Right-clicking on a non-matching hole, or outside of any
hole, as well as left-clicking anywhere, will abort a drag-and-drop operation
and cancel the object's selection.
Mechanism of
inheritance
meaning to supply an effective version to a
deferred
routine. An
effecting
is similar to a
redefinition;
only here there is no effective definition in the original class, just a
specification in the form of a deferred routine. The term redeclaration
covers both redefinition and effecting.
The basic modular unit in Eiffel describing one
implementation of an abstract data type, i.e., a set of run-time objects,
characterized by the features (operations) applicable to them, and by the
formal properties of these features, or in the case of "
deferred"
classes, a set of possible implementations of the same abstract data type.
Specifies a command to be triggered when a certain
event occurs at a given
TUNE
object. Any number of commands can be assigned to an event - TUNE object
pair.
One of three pages of the iss-build Inspector
Tool; provides access to the
active
element
's
behavior specification. Separate entries in the
Events
page
can be added, modified, or deleted through the iss-buildEvent-Command
Binding
dialog.
Occurs when an
assertion
is violated (if assertions are being monitored) or when a condition is
encountered during the execution of a system which makes it impossible to
continue the computation as planned, for example, after the occurrence of a
signal triggered by the hardware or operating system to indicate an abnormal
condition such as arithmetic overflow or lack of memory.
Unless specific provisions for handling
exceptions
(see also
exception
handling
)
have been made in the given routine, it will fail when an exception
arises during its execution. Failure of a routine is a third cause of
exception: a routine that fails triggers an exception in its caller.
Refers to the operations performed by a system to
"patch things up", enabling the system to continue operation after an
exception
is raised, at least until it is possible to exit properly. Provisions for
handling exceptions can be specified in a routine's
rescue
clause
.
An iss-bench environment tool enabling
the user to explore the object structure interactively at run time and find out
what the system actually does. Every
Execution
Object Tool
represents a run-time object - an instance of some class - captured during the
execution of the system.
An iss-bench environment tool enabling
the user to edit class features; complements the
browsing
and documentation facilities provided by the System and
Class
Tools
.
The
Feature
Tool
is particularly useful in tracking down the many transformations of features in
an
inheritance
hierarchy --
renaming,
redefinition,
effecting,
undefinition.
A dialog box enabling you to traverse the file
hierarchy of your computer system (selecting drives and moving up to a parent
directory or down to a subdirectory) and select a file. This dialog box opens
whenever you are required by one of the iss-base components to select a file.
The
File
Selector
is not actually an iss-base
component; instead, it comes from the underlying window system.
One of three complementary forms of compilation offered by iss-bench. Finalizing generates a
self-contained object module that can be executed independently and produces
the most efficient, executable version of a system and if needed, a C package
that can be ported to various platforms.
Finalizing is a potentially long operation for a
large system; the user will be asked to confirm the request whenever the
Finalize button is clicked.
Provides a filtered version of the class text (
class
interface
)
displaying the Eiffel code as it would in the absence of
inheritance:
All features inherited from
ancestors,
however distant, are included at the same level as the immediate features
(those introduced in the class itself), taking into account any
renaming
and redeclaration that may have occurred; the
invariant
is reconstructed by concatenating the ancestors' invariants with the class's
own; routine
preconditions
and
postconditions
are given in full, integrating the result of any require
elseand ensure
thenclauses.
Provides a filtered version of the class text (
class
interface
)
displaying the Eiffel code without any implementation information (see
Short
format
)
but also as it would in the absence of
inheritance
(see Flat format).
These properties make the
Flat-short
form
the ideal client-oriented documentation for a class. Thus it provides the
official client interface of a class and serves as the primary form of class
documentation, especially for libraries.
Flat and Flat-short take significantly longer to
display than the other formats.
One of three complementary forms of compilation offered by iss-bench. Freezing updates the C
code, so that it integrates all the latest changes, and relinks the system,
bringing the
melted
parts to the same compiled state as the parts which have not been
modified
If your software uses external (non-Eiffel) routines, such as C functions, then
you must refreeze it when you add or change such external elements.
Freezing takes significantly longer than melting
(melting does not require C compilation and linking.) For this reason, the user
is asked to confirm or cancel the request when the
Freeze
button is clicked on.
Defines a
gallery
page
as displayed in the Gallery Tool of iss-build. These files are generated
by iss-build, but they have
a straightforward structure and can be edited with any text editor.
Mechanism for freeing memory allocated to objects
no longer in use. iss-base
uses an incremental garbage collector whose impact on performance is hardly
perceptible, for most applications. You can tailor
garbage
collection
at execution time thanks to procedures of the iss-baselib class
MEMORY.
In particular, garbage collection can be turned on and off or a full cycle
started.
A window that pops up when the user has made some
error, not leaving users any other choice than clicking on
OK.
iss-bencherror
panels
are of the "pseudo-Gotcha" type: You do not need to dismiss them explicitly;
they will go away at your next significant action, for example, when you press
Enter after retyping your entry to correct it, or perform a
drag-and-drop.
"Graphical User Interface". Provides users with a
convenient system of visual elements and techniques (such as windows, mouse
clicks,
drag-and-drop,
etc.) for interacting with a running application.
An area of the user interface where development
objects of the matching type can be dropped for targeting an iss-bench tool. Typed
drag-and-drop,
as represented by iss-bench,
is based on the idea of using
pebbles
and
holes
to match development object with development tool: Right-clicking on a
development object (e.g., a class name) changes the mouse cursor to the
associated pebble (
);
dropping such a pebble into a matching hole (
)
targets an appropriate iss-bench tool (
Class
Tool
)
to that development object.
If a pebble is dropped into a hole that does not match, the drag-and-drop
operation is not completed and the object selection canceled. Left-clicking has
the same effect.
A fundamental generalization mechanism of the
object-oriented
approach.
Inheritance
enables the definition of classes through the combination and specialization of
existing classes.
Inheritance is defined with an inherit clause found in the class
text of the inheriting class. The class appearing in the inherit clause is said
to be the parent. Unless otherwise specified, through
redefinition,
renaming,
effecting,
or undefinition, all of the features of the parent are propagated "as is" to
the inheriting class.
Inheritance not only represents a mechanism for combining and enriching modules
but also forms the base for
polymorphism
-- allowing entities to become attached at run time to objects of various types.
External representation of the
input
format
.
Formatting controls enable the display of masks, which are used to reflect the
structure of the expected data. For example, the mask "_ _:_ _" could be used
for entering time values. A mask consists of a number of placeholders and
formatting characters.
In the given example, the underline is the placeholder for expected input,
whereas the colon is a formatting character, which remains unchanged by data
input.
The iss-build tool providing access to
the attribute and
parent
attribute
settings as well as the
event-command
bindings
of the elements selected in the
active
dialog
.
The
Inspector
Tool is divided into three pages: Attributes, Parent Attributes, and Events.
The values of attributes and parent attributes are edited with the
Attributes
page
and
Parent
page
,
respectively, and the event-command bindings are edited with the
Events
page
.
A general consistency
constraint
(
assertion),
appearing in a clause introduced by the keyword invariant, which is imposed on all
routines of the class. A class
invariant
must be satisfied by every instance of the class whenever the instance is
externally accessible: after creation, and after any call to an exported
routine of the class.
iss-base is a complete development
environment intended for the production of high-quality software. Based on the
Eiffel method and language, iss-base uses the full extent of
object technology, including
assertions
and
exceptions
(based on the theory of Design by Contract), classes, multiple and
repeated
inheritance,
genericity, and many other advanced yet easy to learn features. These
mechanisms provide the basis for building an industry of reusable components,
both general-purpose and application-specific.
iss-base offers not just a compiler
but an integrated suite of development tools and libraries of reusable
components, making it possible to deploy the method and language to their full
extent.
iss-base is based on
industry standards -- the Eiffel language in its latest version, ANSI C, the X
Window system, SQL. The final output of a development is an ANSI-compliant C
package, ensuring portability of the result across a wide variety of
platforms.
The iss-base message system is
responsible for preparing and presenting any type of message that an
application might produce.
The iss-base
message system can be configured in a number of ways to
suit your specific needs, although for less complicated applications it will be
enough if you rely on the default behavior.
iss-baselib is the (
precompiled)
library of reusable components covering the basic needs of many applications in
the areas of fundamental data structures and algorithms.
iss-bench is the development
environment supporting fast compilation, editing of software texts,
browsing,
debugging, and production of C packages for cross-development. You may interact
with iss-bench through a
graphical user interface (
GUI);
a "batch" version, callable from the command line in non-graphical
environments, is also available for the most important
functionalities.
iss-build
is an interactive user-interface and application
builder,
supporting easy visual development of applications with a graphical user
interface. As an ideal extension to the iss-visionuser
interface management system
,
iss-build enables the
interactive development of
TUNEtemplates,
which can be read and generated by iss-build as either TUNE-source-code
or TUNE-binary files.
You can use the graphical tools of iss-case to devise the architecture
of a new system by specifying new
clusters,
classes, and features, interactively; the tools will process your graphical
input to generate
Eiffel
classes
.
This is the forward engineering mode of iss-case. But iss-case also supports reverse
engineering: the production of iss-case structures and
BON
diagrams from existing Eiffel systems. You can alternate freely between the two
modes, combining iss-case-generated structures with
classes produced through iss-bench or text editors.
The classes of the iss-net library will enable you to
support several types of
client-server
computing and the transmission of object structures over
networks.
The library iss-report enables the transmission
of data to as well as the control of report generators. The given framework
provides a uniform interface with the decisive advantage that from the
application side the control of the report generating process is always the
same -- regardless of which report generator is being used or which platform
the application is being developed for.
The iss-store library enables access to
relational database management systems (RDBMS), like Informix, Oracle, Sybase,
Ingres and Microsoft SQL Server, over the Open Database Connectivity (ODBC)
interface. Additionally, with the appropriate ODBC drivers non-relational
data
sources
can also be accessed in a relational manner, for example, Excel spreadsheets,
text files, and hierarchical IBM mainframe databases.
As an
object-orientedODBC
interface
,
iss-store provides the
entire functionality, as well as the flexibility, of ODBC. Moreover, iss-store extends the functionality
of ODBC with additional abstraction levels using
Eiffel
classes
to model, among others, the SQL Data Manipulation Language (DML). Of course,
iss-store permits native
functions of the respective data sources to be used that are not part of the
standard ODBC SQL language.
For queries the extended abstraction levels offer, for example, four different
ways of creating and executing the SQL "Select" statement, which greatly
reduces the number of function calls that need to be coded, especially for the
often needed standard queries.
iss-tune enables the development of
flexible applications that are to be configured dynamically for different areas
of usage. Configurations can be defined in iss-tune hierarchically or centrally
through
object-oriented
mechanisms and then reused. iss-tune is platform-independent
(MS WINDOWS and UNIX).
iss-uml is around-trip engineering environment
based on the UML providing two main components: an Eiffel code generation tool
and a reverse engineering tool. The Eiffel code generation tool enables the
automatic creation of Eiffel sources from a visual specification given in the
form of a structured diagram. The reverse engineering tool produces diagrams
from selected parts of existing Eiffel projects.
The
iss-vision library supplies the graphical objects of the
Win32 Software Development Kit making it possible to build interactive
graphical applications that will run on Windows NT, Windows 95 and Win32s. Edit
controls for formatted input and positioning containers are offered as well.
The library iss-webgate enables the development
of applications that are capable of providing information across the World Wide
Web dynamically and processing information entered in form fields by Web site
visitors. iss-webgate also
supports the exchange of information over web servers utilizing the widely used
Common Gateway Interface (CGI). The provided framework greatly simplifies the
processing of forms developed by means of CGI and thus enables the
implementation of complex information systems across the Internet.
iss-yacc consists of a framework and
a parser generator (ibyacc), based on the principles of
yacc, the popular tool well know in the UNIX world.
ibyacc generates Eiffel code that can be compiled to produce a
parser, which is a program that examines the input stream and, can among other
things, check whether it is syntactically correct according to a given
grammar.
("Language for the Assembly of Classes in Eiffel",
described in detail in Appendix D of the book "Eiffel: The
Language"), a small Eiffel-like language used in
Ace
files for the definition of systems, e.g., where the
clusters
are to be found and how their classes are to be processed.
Options appearing in the default clause of
Lace;
apply only to compilation in final mode. To turn any of them on or off, include
an entry consisting of the option name followed by the option value (yes or no
in most cases) in parentheses, for example:
One of three complementary forms of compilation offered by iss-bench. Melting is much faster
than the other two mechanisms (freezing and finalizing). The melting time is
proportional to the size of the changed parts and affected classes, whereas the
time needed to
freeze
or finalize is in part proportional to the size of the entire system.
Typically, melting will take but a few seconds after small changes.
Offers three forms of compilation serving
complementary purposes: melting (used after making a few changes, since
melting time is proportional to the size of changed part - but will result in
slower executing code than freezing), freezing (after you have made
changes to different parts of the system or to generate C and finalizing
(almost at the and of a project to produce portable, highly optimized ANSI-C
code and a final executable module.
You can trigger them by clicking on one of the
three buttons on the right side of the
Project
Tool
.
An object of a type conforming to ISS_MESSAGE_HANDLER defining a feature for every
message type (error message, warning message, information message,·debug
information message, raise message, and confirm message), specifying the exact
actions to be carried out when a message of the corresponding type is produced.
The iss-base message system
decouples the subsystems from application-specific actions to be performed for
the different message types, allowing the implementation of different
message
handlers
.
For example, a specific handler could use the MS Windows dialog box to display
error messages, whereas information messages could be displayed in a special
region of the application
The iss-build Tool displaying
hierarchically all the objects of the
active
dialog
;
enables the specification of name and export status for the
active
element
.
A group of interconnected computers over which
programs can exchange data, signals, and messages. The programs may be running
on different computers. See also "
client-server".
An object registered at the
TUNE
manager
for creating
TUNE
objects
of a certain type. An
object
creator
must be registered for every type of
TUNE
object belonging to a TUNE configuration. Upon request an object creator will
instantiate a TUNE object of the specified type. Object creators are themselves
of a type that conforms to TUNE_OBJECT_CREATOR.
Refers to a development approach where software is
defined by a structured collection of data abstractions, each
represented by a class. For example, a system which manages a book
library may be based on classes representing such data abstractions as BOOK, BORROWER, CATALOG, and TRANSACTION. At execution time, the software will
manipulate objects: individual instances of these classes, for example,
individual books, borrowers, catalogs, transactions.
Building software components (classes) as
implementations of abstract data types yields systems with a solid architecture
but does not in itself suffice to ensure reusability and extendibility,
properties expected of
object-oriented
software. Two key object-oriented techniques address these problems: genericity
(unconstrained or constrained) and
inheritance.
Other key concepts covered by a truly object-oriented language, like Eiffel,
include
assertions,
static typing, covariance,
exception
handling
,
garbage
collection
,
redefinition,
polymorphism,
dynamic binding, and information hiding -- which all, more or less, follow from
the foundational idea of data abstraction.
Finally, the design and construction of an object-oriented system should be
based on an
object-oriented
environment
,
like iss-base.
A development environment that not only enables
the development of
object-oriented
software but which also provides an object-oriented user interface. If the
method is object-oriented; the environment should be so, too. This means that
the units of interaction between the developers and their environment are of
the same nature as the units of software development: In other words, they are
data abstractions, too.
The developers' data abstractions, however, are
one level of abstraction higher. Where classes (execution abstractions) had, as
their instances, such execution objects as books and transactions, the
abstractions directly relevant to software developers are those which describe
the software artifacts that developers create, use, and modify.
In the same way that execution objects are instances of execution abstractions
(classes), development objects are instances of development
abstractions. The iss-bench
environment provides you with seven Tools categories of
development abstraction - Class, Project, System, Feature, Explanation,
Execution Object and Stop Point - according to the following key
rules.
An
object-oriented
environment
must be defined by a set of development abstractions, each modeling a type of
development object. For each fundamental development abstraction the
environment must provide a corresponding tool, enabling its users to apply
queries and commands to development objects of the associated type.
An object-oriented environment should support the direct manipulation of
development objects. A powerful technique for achieving this goal is to
associate with each development object a
pebble,
which can be drag-and-dropped into matching
holes
of a corresponding object tool, and to use the tool's buttons to apply
operations to the object.
An object-oriented environment should enable its users, for any symbol
(textual, graphical or otherwise) representing a development object in the user
interface, to select the object through the symbol and apply any operation that
is semantically valid for the object, regardless of the symbol's context --
tool, location, format, representation.
An object-oriented environment should associate a type with every development
object, ensure that each object's type is immediately apparent from the
object's visual representation, define simple rules as to what operations and
combinations are permitted on objects and tools of each possible type, and
enforce these rules through interaction techniques that favor error avoidance
over a posteriori detection and correction.
An open, vendor-neutral interface for database
connectivity that provides access to a variety of personal computer,
minicomputer, and mainframe systems, including Windows-based systems and the
Apple Macintosh. The
ODBC
interface
permits an application developer to develop, compile, and ship an application
without targeting a specific database management system (DBMS). Users can add
modules called database drivers that link the application to their choice of
database management systems.
Processes ODBC function calls, submits SQL
requests to a specific
data
source
,
and returns results to the application. If necessary, the driver modifies an
application's request so that the request conforms to syntax supported by the
associated DBMS.
Conversion of a value of a specific type into a
string under consideration of certain formatting options such as alignment,
insertion of
formatting
characters
etc. In formatting controls the
output
formatting
is carried out after the field specific checks have been performed
successfully.
An attribute of a child
TUNE
object that can be used by a parent TUNE
composite
to configure the layout of the child. For example, the alignment attributes of
a TUNE object contained in a TUNE composite represent
parent
attributes
.
The PC-Warehouse is a small but
extendible practical application of all components of iss-base: iss-vision, iss-build, iss-store, iss-net and iss-webgate.
A small cursor icon of the appropriate type which
appears when a development object is selected.
Pebbles
can be dropped into matching
holes
for targeting a corresponding object tool and used to apply operations to the
selected object with tool buttons.
A concept of the
object-oriented
approach allowing an entity to reference objects of various types at run time.
This remarkable facility must, however, be
reconciled with static typing. The language convention is simple: an assignment
of the form a := b is permitted not only if a and b
are of the same type, but more generally if a and b
are of reference types Aand B, based on classes Aand B, such that Bis a
descendant
of A.
This corresponds to the intuitive idea that a value of a more specialized type
may be assigned to an entity of a less specialized type -- but not the reverse.
An
assertion
at the routine level expressing the requirements the routine (the supplier)
guarantees on return, if the
precondition
was satisfied on entry.
Postconditions
are introduced by the keyword ensure.
A form of compilation (used with libraries) that
differs slightly from normal compilation: entire
clusters
are compiled, whether or not the individual classes are needed by the root; all
needed clusters (through client and
inheritance
relations) must be
precompiled
in the same precompilation step.
Precompilation enables you to compile a library,
or a combination of libraries, once and for all. The benefits are considerable
in both time and space: you save compilation time since the iss-bench compilation mechanism will
only concern itself with non-precompiled classes; you save on disk space, since
the space taken up by precompiled libraries is shared by all projects using
these libraries. Without precompilation, every project of every developer would
have to keep a compiled form of the libraries.
Precompilation also enables library developers, if they so desire, to
distribute a library without distributing the source text of its classes, or
with the source text of some classes only.
A given project may rely on at most one precompiled library or (more
commonly) combination of libraries. You may, of course, prepare as many
precompiled combinations as you want, but each project must select the precise
combination that it needs.
A set of high-level classes of the iss-net library that provide a
complete framework covering the most common uses.
Writing
client-server
applications, especially their communication aspects, is an arduous task;
developers must master many tricky details of
socket
programming and other low-level mechanisms. iss-net hides this complexity by
providing ready-made classes addressing the most common cases, so that
developers only have to describe what is specific to their application, letting
iss-net handle the whole
process of communication and synchronization between clients and servers. These
classes represent the
predefined
level
of iss-net and for many uses
they are the only classes that will be needed. For developments requiring a
finer degree of control, all the major mechanisms of socket programming are
still accessible in a convenient form through more specialized classes.
An
assertion
at the routine level expressing the requirements that clients must satisfy
whenever they call the routine.
Preconditions
are introduced by the keyword require.
A directory where project-related files are stored
(above all
Ace
files) and where the compiler will store its own internal files, using a
subdirectory called EIFGEN. Even for a new project, the
project
directory
must exist before you start the session; you cannot create it from within the
environment.
It is desirable, especially for a large system, to
make sure that the project directory (more specifically, the
EIFGEN subdirectory) be physically located on a local disk
rather than on a disk accessible only through the
network.
On WINDOWS the project directory will serve as the execution directory
for interpreting relative file names.
A list of the projects last loaded which appears
at the bottom of the Project menu. Selecting one entry of this
list loads the corresponding project into iss-build.
An iss-bench
environment tool serving as a control panel for any
session with iss-bench. It
enables the selection of a specific project and governs the compiling,
executing, and debugging functions as well as the initial launching of other
tools.
A mechanism of
inheritance
enabling the redeclaration of inherited features and effective routines. A
class may redefine some or all of the features which it inherits. For an
attribute or function, the
redefinition
may affect the type, replacing the original by a
descendant;
for a routine it may also affect the implementation, replacing the original's
routine body by a new one.
In any case the rules governing redeclaration comply:
If the type of a feature, result, or argument is changed, the new type must be
a descendent of the old.
For routines the number of arguments cannot be modified and there cannot be a
switch between command and query.
A mechanism of
inheritance
enabling name changes for features that have been inherited. The very power of
inheritance demands adequate means to keep it under control. Multiple
inheritance, in particular, raises the question of name conflicts between
features inherited from different parents. Such name conflicts can be resolved
through
renaming.
Renaming also serves to provide more appropriate
feature names in
descendants
leading to object coherent terminology.
Eiffel constructs for handling
exceptions.
A
rescue
clause
can be specified for each routine and contains instructions that are to be
performed when an exception occurs during routine execution.
Typically, a rescue clause will include instructions aimed at stabilizing the
state of the current object. It can also contain a retry instruction at the end
of the clause which causes the routine to restart its execution from the
beginning, attempting again to fulfill its contract, usually through another
strategy. This assumes that the instructions of the rescue clause, before the
retry, have attempted to correct the cause of the exception. If the rescue
clause does not contain a retry instruction, the routine fails.
A call to a
resource
manager
to determine the attribute of a
TUNE
object dynamically. In TUNE an attribute of a TUNE object can be configured by
assigning to the attribute either a constant value, or a
resource
call
that is evaluated by the specified resource manager when the
template
is instantiated.
File containing information needed to configure an
application dynamically at run time. One resource entry consists of a pair
(resource key - value) to be read by the application.
A class designated in a system's
Ace
file as
root
class
with a creation procedure that is designated as the root creation
procedure.
A valid system is executable. To execute it means
to create an instance of the root class and to apply the creation procedure to
that instance. The creation procedure, which plays a role similar to that of a
test driver in more traditional approaches, will normally create other objects
and call further features.
Starts the execution of an application once it has been compiled.
Basic
click
on the
Run
button
starts or resumes execution; however, you can
right-click
on that same button to specify the arguments for the next run.
You can interrupt execution at any time by clicking on the End Run
button, and terminate it by Control-clicking that button. When execution
terminates, either normally or through Control-End Run, the
Project
Tool
will display the message System terminated.
One of two modes in which a dialog can be opened
in iss-build. To examine
your dialog as it would appear in a real application, toggle to
Runtime
mode
with the rightmost toolbar button of the iss-build bench.
Opens a Search panel for searching the text contained in a tool window for
occurrences of a certain string.
Type the string that you want to find in the text
of the tool's target into the text field at the top. Then press the Enter (or
Return) key or
click
on the Next button. If there is no occurrence of the search string in the
target's text, this operation will have no effect; otherwise, it will highlight
the next occurrence of the string on or after the currently active position in
the target. Searching is not case-sensitive.
To search for successive occurrences, repeatedly press Enter, in the Search
panel, or click on Next. The searching command wraps around the
end of the text.
An
object-oriented
environment
should enable its users, for any symbol (textual, graphical or otherwise)
representing a development object in the user interface, to select the object
through the symbol and apply any operation that is semantically valid for the
object, regardless of the symbol's context -- tool, location, format,
representation.
Located at the bottom of the right border just above the rightmost format,
invokes the currently defined shell command. By default, the default editor is
started, targeted to the class being edited. The effect of clicking on the
button can be redefined by right-clickingon the button.
Provides a filtered version of the class text (
class
interface
)
displaying an abstract form, without any implementation information. It is
obtained from the class text by removing non-exported or selectively exported
features, and routine bodies (once, do and
external clauses). For each exported
feature, the short form retains the feature name, the signature (arguments,
result, and if any, their types), the header comment, and the
assertions.
It also retains the class
invariant
and the indexing clause
A communication port. A software system will
exchange objects with another system by sending the objects to a
socket.
By connecting sockets you enable communication between systems, for example, a
client and a server:
iss-net has been designed to make
sockets look very much like files. You send objects to a socket in the same way
that you write objects onto a file, and receive objects from a socket in the
same way that you read objects from a file. This fundamental commonality is
reflected in the
inheritance
hierarchy of the corresponding classes.
A sequence of elements of identical type.
Special
objects
are used to represent strings, for which the elements are characters, and
arrays, for which the elements are of the type declared for the array.
An approach to software construction where every
object has a well-defined type, which results from the declaration of the
corresponding entity. Eiffel is strongly typed for readability and reliability.
Every entity is declared of a certain type, which may be either a reference
type or an expanded type.
Any type Tis based on a class, which defines the
operations that will be applicable to instances of T. The difference between the two categories of
type affects the semantics of an entity xdeclared of type T: for a reference type, the most common case,
possible values for xare
references to objects; for an expanded type, the values are objects. In both
cases, the type rules guarantee that the objects will be instances of T.
An iss-bench
environment tool enabling the creation, examination, and
modification of
Ace
files, also providing a convenient way to examine the overall structure of a
system and access its
clusters
A window displayed on the MS Windows desktop,
showing a title bar, minimize and maximize buttons, a system menu, and so
forth. The first window created by an application must be
top-level
window
conforming to UI_MS_FRAME (part of iss-vision), and all other top-level
windows should have this window as parent.
A set of directories, each defining a
cluster,
together containing all classes of any of the clusters associated with the
given system. In other words, the classes of the
universe
are the contents of all the class files (by default, all the *.e files)
in these directories.
Rule expressing properties that syntactically
correct elements must satisfy if they are to yield meaningful software.
Eiffel's consistency properties (also known as the static semantics of
the language) are defined by seventy-three validity
constraints.
Such constraints serve to enforce the type rules (making Eiffel a statically
typed language), the proper use of
inheritance,
the information hiding principle, and other important design rules associated
with the Eiffel method and language.
Each validity constraint is identified in the book
"Eiffel: The Language" by a code of four letters of which the first is
always V (for Validity). If such an error occurs and assuming the message was
not sufficient to understand the error, the code could be drag-and-dropped into
the corresponding Explanation
hole
of the
Project
Tool
.
This will display the complete text of the violated rule.
Eiffel
class
providing to the application features for direct access to the exported
TUNE
objects
of a
template
as well as other features for manipulating the template, e.g., loading,
resetting, freeing, performing input validation, etc.