FACTOID # 21: 15% of Army recruits from South Dakota are Native American, which is roughly the same percentage for female Army recruits in the state.
 
 Home   Encyclopedia   Statistics   States A-Z   Flags   Maps   FAQ   About 
   
 
WHAT'S NEW
 

SEARCH ALL

FACTS & STATISTICS    Advanced view

Search encyclopedia, statistics and forums:

 

 

(* = Graphable)

 

 


Encyclopedia > Eiffel (programming language)
Eiffel
Paradigm object-oriented
Appeared in 1986
Designed by Bertrand Meyer
Developer Bertrand Meyer & Eiffel Software
Typing discipline static typing, strong typing
Major implementations EiffelStudio, SmartEiffel, Visual Eiffel
Influenced by Ada, Simula, Z
Influenced Sather, Ruby, Java, C#, D

Eiffel is an ISO-standardized, object-oriented programming language designed to enable programmers efficiently to develop extensible, reusable, reliable software. Eiffel is used in academia as a language for teaching computer-programming principles. Eiffel is used in the finance, aerospace, health-care, video-gaming, and other industries as a development platform. Since 1985, many suppliers have developed Eiffel programming environments. A programming paradigm is a paradigmatic style of programming (compare with a methodology, which is a paradigmatic style of doing software engineering). ... Object-oriented programming (OOP) is a programming paradigm that uses objects and their interactions to design applications and computer programs. ... Year 1986 (MCMLXXXVI) was a common year starting on Wednesday (link displays 1986 Gregorian calendar). ... Bertrand Meyer (born 1950 in France) developed the Eiffel programming language, and is an author, academic and consultant in the field of computer languages. ... For other uses, see Software developer (disambiguation). ... Bertrand Meyer (born 1950 in France) developed the Eiffel programming language, and is an author, academic and consultant in the field of computer languages. ... Eiffel Software (previously known as Interactive Software Engineering Inc. ... In computer science, a type system defines how a programming language classifies values and expressions into types, how it can manipulate those types and how they interact. ... On computer science, a datatype (often simply type) is a name or label for a set of values and some operations which can be performed on that set of values. ... In computing, strongly-typed, when applied to a programming language, is used to describe how the language handles datatypes. ... Look up Implementation in Wiktionary, the free dictionary. ... EiffelStudio is a development environment for the Eiffel programming language developed and distributed by Eiffel Software. ... {{Infobox_Software | name = SmartEiffel | screenshot = | caption = | developer = The SmartEiffel Team | latest_release_version = 2. ... Visual Eiffel is an implementation of the Eiffel programming language developed and distributed by Object Tools GmbH, a German company. ... Ada is a structured, statically typed, imperative, and object-oriented high-level computer programming language. ... Simula is a name for two programming languages, Simula I and Simula 67, developed in the 1960s at the Norwegian Computing Center in Oslo, by Ole-Johan Dahl and Kristen Nygaard. ... The Z notation (universally pronounced zed, named after Zermelo-Fränkel set theory) is a formal specification language used for describing and modelling computing systems. ... Sather is an object-oriented programming language. ... Ruby is a reflective, dynamic, object-oriented programming language. ... Java language redirects here. ... The title given to this article is incorrect due to technical limitations. ... For other programming languages named D, see D (disambiguation)#Computing. ... “ISO” redirects here. ... Object-oriented programming (OOP) is a computer programming paradigm in which a software system is modeled as a set of objects that interact with each other. ... A programming language is an artificial language that can be used to control the behavior of a machine, particularly a computer. ...


The Eiffel language's design is closely connected with the Eiffel programming method. Both are based on a set of principles, including design by contract, command-query separation, uniform-access principle, single-choice principle, open-closed principle, and option-operand separation. Design by contract, DBC or Programming by contract is a methodology for designing computer software. ... Command-query separation (CQS) is a principle of object-oriented computer programming. ... The uniform access principle is a principle in the design of object-oriented programming languages. ... The single choice principle is a principle of imperative computer programming. ... In object-oriented programming, a class which follows the open/closed principle is a class which is both open and closed, where open means it has the ability to be extended and closed means it cannot be modified other than by extension. ...


Many concepts initially introduced by Eiffel have later found their way into Java, C#, and other languages. New language-design ideas, particularly through the ECMA/ISO standardization process, continue to be incorporated into the Eiffel language. Ecma International - European association for standardising information and communication systems came into existence in 1994, when the European Computer Manufacturers Association (ECMA) changed its name in order to reflect the international activities of the organisation (the long form of ECMA was dropped then, and capitalization changed to reflect this). ... The International Organization for Standardization (ISO) is an international standard-setting body composed of representatives from national standards bodies. ...

Contents

Characteristics

The key characteristics of the Eiffel language include:

  • An object-oriented program structure in which a class serves as the basic unit of decomposition.
  • Design by contract tightly integrated with other language constructs.
  • Automatic memory management, typically implemented by garbage collection.
  • Inheritance, including multiple inheritance, renaming, redefinition, "select", non-conforming inheritance, and other mechanisms intended to make inheritance safe.
  • Constrained and unconstrained generic programming.
  • A uniform type system handling both value and reference semantics in which all types, including basic types such as INTEGER, are class-based.
  • Type safety (static typing).
  • Void safety, or static protection against calls on null references, through the attached-types mechanism.
  • Agents, or objects that wrap computations, closely connected with closures and lambda calculus.
  • Once routines, or routines evaluated only once, for object sharing and decentralized initialization.
  • Keyword-based syntax in the ALGOL/Pascal tradition but separator-free, insofar as semicolons are optional, with operator syntax available for routines.
  • Case insensitivity.

Design by contract, DBC or Programming by contract is a methodology for designing computer software. ... In computer science, garbage collection (GC) is a form of automatic memory management. ... This article or section does not cite any references or sources. ... Multiple inheritance refers to a feature of object-oriented programming languages in which a class can inherit behaviors and features from more than one superclass. ... It has been suggested that CallSuper be merged into this article or section. ... Generic programming is a style of computer programming where algorithms are written in an extended grammar and are made adaptable by specifying variable parts that are then somehow instantiated later by the compiler with respect to the base grammar. ... On computer science, a datatype (often simply type) is a name or label for a set of values and some operations which can be performed on that set of values. ... In computer science, a closure is a function that is evaluated in an environment containing one or more bound variables. ... The lambda calculus is a formal system designed to investigate function definition, function application, and recursion. ... It has been suggested that ALGOL object code be merged into this article or section. ... Pascal is a structured imperative computer programming language, developed in 1970 by Niklaus Wirth as a language particularly suitable for structured programming. ...

Design goals

Eiffel emphasizes declarative statements over procedural code and attempts to eliminate the need for bookkeeping instructions.


Eiffel shuns coding tricks or coding techniques intended as optimization hints to the compiler. The aim is not only to make the code more readable, but also to allow programmers to concentrate on the important aspects of a program without getting bogged down in implementation details. Eiffel's simplicity is intended to promote simple, extensible, reusable, and reliable answers to computing problems. Compilers for computer programs written in Eiffel provide extensive optimization techniques, such as automatic in-lining, that relieve the programmer of part of the optimization burden while producing code whose efficiency is comparable to that of code written in C++. In computing, optimization is the process of modifying a system to make some aspect of it work more efficiently or use fewer resources. ... C++ (pronounced ) is a general-purpose programming language. ...


Background

Eiffel was originally developed by Eiffel Software, a company originally called Interactive Software Engineering Inc. (ISE) founded by Bertrand Meyer. Object-Oriented Software Construction contains a detailed treatment of the concepts and theory of the object technology that led to Eiffel's design.[1] Eiffel Software (previously known as Interactive Software Engineering Inc. ... Bertrand Meyer (born 1950 in France) developed the Eiffel programming language, and is an author, academic and consultant in the field of computer languages. ... Object-Oriented Software Construction is the title of a book by Bertrand Meyer, widely considered a foundational text of object-oriented programming. ...


The design goal behind the Eiffel language, libraries, and programming methods is to enable programmers to create reliable, reusable software modules. Eiffel supports multiple inheritance, genericity, polymorphism, encapsulation, type-safe conversions, and parameter covariance. Eiffel's most important contribution to software engineering is design by contract (DbC), in which assertions, preconditions, postconditions, and class invariants are employed to help ensure program correctness without sacrificing efficiency. Multiple inheritance refers to a feature of object-oriented programming languages in which a class can inherit behaviors and features from more than one superclass. ... In computer science, generics is a technique that allows one value to take different datatypes (so-called polymorphism) as long as certain contracts such as subtypes and signature are kept. ... In computer science, polymorphism means allowing a single definition to be used with different types of data (specifically, different classes of objects). ... Encapsulation may refer to: information hiding and separation of concerns, in software engineering, the process of enclosing programming elements inside larger, more abstract entities integrated circuit encapsulation, in electronics the design and manufacture of protective packages micro-encapsulation, means to confine material molecular encapsulation, means to confine molecules encapsulation (pharmacology... If a class is inherited and a feature/method/attribute redefined, a parameter or return type can be changed to be a more specialised type. ... Software engineering is the application of a systematic, disciplined, quantifiable approach to the development, operation, and maintenance of software. ... Design by contract, DBC or Programming by contract is a methodology for designing computer software. ... The braces are included in the comment in order to help distinguish this use of a comment from other uses. ... In logic a precondition is a condition that has to be met, before a main argument can have any value. ... A postcondition is a fact that must always be true just after the execution of some section of code. ... In computer programming, a class invariant is an invariant used to constrain objects of a class. ...


Eiffel's design is based on object-oriented programming theory, with only minor influence of other paradigms or concern for support of legacy code. Eiffel formally supports abstract data types. Under Eiffel's design, a software text should be able to reproduce its design documentation from the text itself, using a formalized implementation of the "Abstract Data Type". In computing, an abstract data type (ADT) is a specification of a set of data and the set of operations that can be performed on the data. ...


Implementations and environments

EiffelStudio is an integrated development environment available under either an open source or a commercial license. It offers an object-oriented environment for software engineering. EiffelEnvision is a plug-in for Microsoft Visual Studio that allows users to edit, compile, and debug Eiffel projects from within the Microsoft Visual Studio IDE. EiffelStudio and EiffelEnvision are free for non-commercial use. Three other open source implementations are available: Gobo Eiffel, SmartEiffel—the GNU implementation, based on an older version of the language—and Visual Eiffel. EiffelStudio is a development environment for the Eiffel programming language developed and distributed by Eiffel Software. ... An integrated development environment (IDE), also known as integrated design environment and integrated debugging environment, is a programming environment that has been packaged as an application program,that assists computer programmers in developing software. ... For other uses, see Open source (disambiguation). ... Software engineering is the application of a systematic, disciplined, quantifiable approach to the development, operation, and maintenance of software. ... Microsoft Visual Studio is Microsofts flagship software development product for computer programmers. ... For other uses, see Open source (disambiguation). ... {{Infobox_Software | name = SmartEiffel | screenshot = | caption = | developer = The SmartEiffel Team | latest_release_version = 2. ... Visual Eiffel is an implementation of the Eiffel programming language developed and distributed by Object Tools GmbH, a German company. ...


Several other programming languages incorporate elements first introduced in Eiffel. Sather, for example, was originally based on Eiffel but has since diverged, and now includes several functional programming features. The interactive-teaching language Blue, forerunner of BlueJ, is also Eiffel-based. The Apple Media Tool includes an Eiffel-based Apple Media Language. Sather is an object-oriented programming language. ... Functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions and avoids state and mutable data. ... Blue is a free system for teaching object-oriented programming, developed in Monash University. ... BlueJ running on Mac OS X is an interactive Java development environment, developed mainly for educational purposes, but also suitable for small-scale development. ... The Apple Media Tool was a multimedia authoring tool and associated programming environment sold by Apple in the late 1990s. ...


Specifications and standards

The Eiffel language definition is an international standard of the ISO. The standard was developed by ECMA International, which first approved the standard on 21 June 2005 as ECMA standard 367, Eiffel: Analysis, Design and Implementation Language. In June 2006, ECMA and ISO adopted the second version. In November 2006, ISO first published that version. The standard can be found and used free of charge on the ECMA site.[2] The ISO version[3] is identical in all respects except formatting. “ISO” redirects here. ... Ecma International - European association for standardising information and communication systems came into existence in 1994, when the European Computer Manufacturers Association (ECMA) changed its name in order to reflect the international activities of the organisation (the long form of ECMA was dropped then, and capitalization changed to reflect this). ... is the 172nd day of the year (173rd in leap years) in the Gregorian calendar. ... Year 2005 (MMV) was a common year starting on Saturday (link displays full calendar) of the Gregorian calendar. ... Year 2006 (MMVI) was a common year starting on Sunday of the Gregorian calendar. ... Year 2006 (MMVI) was a common year starting on Sunday of the Gregorian calendar. ...


Eiffel Software and Eiffel-library-developer Gobo have committed to implementing the standard; Eiffel Software's EiffelStudio 6.1 implements some of the major new mechanisms—in particular, inline agents, assigner commands, bracket notation, non-conforming inheritance, and attached types. The SmartEiffel team has turned away from this standard to create its own version of the language, which they believe to be closer to the original style of Eiffel. Object Tools has not disclosed whether future versions of its Eiffel compiler will comply with the standard. {{Infobox_Software | name = SmartEiffel | screenshot = | caption = | developer = The SmartEiffel Team | latest_release_version = 2. ...


The standard cites the following, predecessor Eiffel-language specifications:

  • Bertrand Meyer: Eiffel: The Language, Prentice Hall, second printing, 1992 (first printing: 1991)
  • Bertrand Meyer: Standard Eiffel (revision of preceding entry), ongoing, 1997-present, at Bertrand Meyer's ETL3 page, and
  • Bertrand Meyer: Object-Oriented Software Construction, Prentice Hall: first edition, 1988; second edition, 1997.

Syntax and semantics

Overall structure

An Eiffel "system" or "program" is a collection of classes. Above the level of classes, Eiffel defines cluster, which are essentially a group of classes, and possibly of subclusters (nested clusters). Clusters are not a syntactic language construct, but rather a standard organizational convention. Typically an Eiffel application will be organized with each class in a separate file, and each cluster in a directory containing class files. In this organization, subclusters are subdirectories. For example, under standard organizational and casing conventions, x.e might be the name of a file that defines a class called X.


A class contains features, which are similar to "members", "attributes" or "methods" in other object-oriented programming languages. A class also defines its invariants, and contains other properties, such as a "notes" section for documentation. Eiffel's standard data types, such as ARRAY are all themselves classes, and collections are modified and accessed via features rather than special syntax. Moreover, unlike some "impure" object-oriented languages like Java, Eiffel eschews "basic data types" outside of its class system.


Every system must have a class designated as "root", with one of its creation procedures designated as "root procedure". Executing a system consists of creating an instance of the root class and executing its root procedure. Generally, doing so creates new objects, calls new features, and so on.


Eiffel has six basic executable instructions: assignment; object creation; routine call; conditional; iteration; and choice. Eiffel's control structures are strict in enforcing structured programming: every block has exactly one entry and exactly one exit.


Scoping

Unlike many object-oriented languages, but like Smalltalk, Eiffel does not permit any assignment into fields of objects, except within the features of an object. Eiffel emphasizes information hiding and data abstraction, by requiring formal interfaces to data mutation. To put it in the language of other object-oriented programming languages, all Eiffel fields are "private", and "setters" are needed to modify values. An upshot of this is that "setters" can, and normally do, implement the invariants Eiffel provides syntax for. Smalltalk is a dynamically typed object oriented programming language designed at Xerox PARC by Alan Kay, Dan Ingalls, Ted Kaehler, Adele Goldberg, and others during the 1970s. ...


"Hello, world!"

A programming language's look and feel is often conveyed using a "Hello, world!" program. Such a program written in Eiffel might be:

 class HELLO_WORLD create make feature make do print ("Hello, world!%N") end end 

Design by Contract

The concept of Design by Contract is central to Eiffel. The mechanisms are tightly integrated with the language. Contracts guide redefinition of features in inheritance. Design by contract, DBC or Programming by contract is a methodology for designing computer software. ...

  • Routine precondition: The precondition may only be weakened by inheritance; any call that meets the requirements of the ancestor meets those of the descendant.
  • Routine postcondition: The postcondition can only be strengthened by inheritance; any result guaranteed by the ancestor is still provided by the descendant.
  • Class invariant

In addition, the language supports a "check instruction" (a kind of "assert") and loop invariants.


Features, commands, queries

The primary characteristic of a class is that it contains a set of features. As a class represents a set of run-time objects, or "instances", a feature is an operation on these objects. There are two kinds of features: queries and commands. A query provides information about an instance. A command modifies an instance.


The command-query distinction is important to the Eiffel method. In particular:

  • Uniform-Access Principle: from the point of view of a software client making a call to a class feature, whether a query is an attribute (field in each object) or a function (algorithm) should not make any difference. For example a_vehicle.speed could be an attribute, accessed from the object's representation; or it could be computed by a function that divides distance by time. The notation is the same in both cases, so that it's easy to change representation without affecting the rest of the software.
  • Command-Query Separation Principle: Queries must not modify the instance. This is not a language rule but a methodological principle. So in good Eiffel style, one does not find "get" functions that change something and return a result; instead there are commands (procedures) to change objects, and queries to obtain information about the object, resulting from preceding changes.

Command-query separation (CQS) is a principle of object-oriented computer programming. ...

Overloading

Eiffel does not allow argument overloading. Each feature name within a class always maps to a specific feature within the class. One name, within one class, means one thing. Method overloading is a feature found in various programming languages such as C++ and Java that allows the creation of several functions with the same name which differ from each other in terms of the type of the inbananaput and the type of the output of the function. ...


This design choice helps the readability of classes, by avoiding a cause of ambiguity about which routine will be invoked by a call. It also simplifies the language mechanism; in particular, this is what makes Eiffel's multiple inheritance mechanism possible.[4]


Names can, of course, be reused in different classes. For example the "+" operator is defined in several classes: INTEGER, REAL, STRING, etc.


Genericity

Classes can be generic, to express that they are parameterized by types. Generic parameters appear in square brackets:

 class LIST [G] ... 

G is known as a "formal generic parameter". (Eiffel reserves "argument" for routines, and uses "parameter" only for generic classes.) With such a declaration G represents within the class an arbitrary type; so a function can return a value of type G, and a routine can take an argument of that type:

 item: G do ... end put (x: G) do ... end 

The LIST [INTEGER] and LIST [WORD] are "generic derivations" of this class. Permitted combinations (with n: INTEGER, w: WORD, il: LIST [INTEGER], wl: LIST [WORD]) are

 n := il.item wl.put (w) 

INTEGER resp. WORD are the "actual generic parameters" in these generic derivations.


It is also possible to have 'constrained' formal parameters, for which the actual parameter must inherit from a given class, the "constraint". For example in

 class HASH_TABLE [G, KEY -> HASHABLE] 

a derivation HASH_TABLE [INTEGER, STRING] is valid only if STRING inherits from HASHABLE (as it indeed does in typical Eiffel libraries). Within the class, having KEY constrained by HASHABLE means that for x: KEY it is possible to apply to x all the features of HASHABLE, as in x.hash_code.


Inheritance basics

To inherit from one or more others, a class will include an inherit clause at the beginning:

 class C inherit A B -- ... Rest of class declaration ... 

The class may redefine (override) some or all of the inherited features. This must be explicitly announced at the beginning of the class through a redefine subclause of the inheritance clause, as in

 class C inherit A redefine f, g, h end B redefine u, v end 

Deferred classes and features

Classes may be defined with deferred class rather than with class to indicate that the class may not be directly instantiated. Non-instantiatable classes are called abstract classes in some other object-oriented programming languages. In Eiffel parlance, only an "effective" class can be instantiated (it may be a descendent of a deferred class). A feature can also be deferred by using the deferred keyword in place of a do clause. If a class has any deferred features it must be declared as deferred; however, a class with no deferred features may nonetheless itself be deferred. In object-oriented programming, a class consists of encapsulated instance variables and subprograms, the methods mentioned below. ...


Deferred classes play some of the same role as interfaces in languages such as Java, though many object-oriented programming theorists believe interfaces are themselves largely an answer to Java's lack of multiple inheritance (which Eiffel has).


Renaming

A class that inherits from one or more others gets all its features, by default under their original names. It may, however, change their names through rename clauses. This is required in the case of multiple inheritance if there are name clashes between inherited features; without renaming, the resulting class would violate the no-overloading principle noted above and hence would be invalid.


Tuples

Tuples types may be viewed as a simple form of class, providing only attributes and the corresponding "setter" procedure. A typical tuple type reads

 TUPLE [name: STRING; weight: REAL; date: DATE] 

and could be use to describe a simple notion of birth record if a class is not needed. An instance of such a tuple is simply a sequence of values with the given types, given in brackets, such as

 ["Brigitte", 3.5, Last_night] 

Components of such a tuple can be accessed as if the tuple tags were attributes of a class, for example if t has been assigned the above tuple then t.weight has value 3.5.


Thanks to the notion of assigner command (see below), dot notation can also be used to assign components of such a tuple, as in

 t.weight := t.weight + 0.5 

The tuple tags are optional, so that it is also possible to write a tuple type as TUPLE [STRING, REAL, DATE]. (In some compilers this is the only form of tuple, as tags were introduced with the ECMA standard.)


The precise specification of e.g. TUPLE [A, B, C] is that it describes sequences of at least three elements, the first three being of types A, B, C respectively. As a result TUPLE [A, B, C] conforms to (may be assigned to) TUPLE [A, B], to TUPLE [A] and to TUPLE (without parameters), the topmost tuple type to which all tuple types conform.


Agents

Eiffel's "agent" mechanism wraps operations into objects. This mechanism can be used for iteration, event-driven programming, and other contexts in which it is useful to pass operations around the program structure. Other programming languages, especially ones that emphasize functional programming, allow a similar pattern using continuations, closures, or generators; Eiffel's agents emphasize the language's object-oriented paradigm, and use a syntax and semantics similar to code blocks in Smalltalk and Ruby. Functional programming is a programming paradigm that treats computation as the evaluation of mathematical functions and avoids state and mutable data. ... This page is about the computer science continuation. ... In computer science, a closure is a function that is evaluated in an environment containing one or more bound variables. ... In computer science, a generator is a special routine that can be used to control the iteration behaviour of a loop. ... Smalltalk is a dynamically typed object oriented programming language designed at Xerox PARC by Alan Kay, Dan Ingalls, Ted Kaehler, Adele Goldberg, and others during the 1970s. ... Ruby is a reflective, dynamic, object-oriented programming language. ...


For example, to execute the my_action block for each element of my_list, one would write:

 my_list.do_all (agent my_action) 

To execute my_action only on elements satisfying my_condition, a limitation/filter can be added:

 my_list.do_if (agent my_action, agent my_condition) 

In these examples, my_action and my_condition are routines. Prefixing them with agent yields an object that represents the corresponding routine with all its properties, in particular the ability to be called with the appropriate arguments. So if a represents that object (for example because a is the argument to do_all), the instruction

 a.call ([x]) 

will call the original routine with the argument x, as if we had directly called the original routine: my_action (x). Arguments to call are passed as a tuple, here [x].


It is possible to keep some arguments to an agent open and make others closed. The open arguments are passed as arguments to call: they are provided at the time of agent use. The closed arguments are provided at the time of agent definition. For example, if action2 has two arguments, the iteration

 my_list.do_all (agent action2 (?, y)) 

iterates action2 (x, y) for successive values of x, where the second arguments remained set to y. The question mark ? indicates an open argument; y is a closed argument of the agent. Note that the basic syntax agent f is a short hand for agent f (?, ?, ...) with all arguments open. It is also possible to make the target of an agent open through the notation {T}? where T is the type of the target.


The distinction between open and closed operands (operands = arguments + target) corresponds to the distinction between bound and free variables in lambda calculus. An agent expression such as action2 (?, y) with some operands closed and some open corresponds to a version of the original operation curried on the closed operands. The lambda calculus is a formal system designed to investigate function definition, function application, and recursion. ... This article is about the function transformation technique. ...


The agent mechanism has been recently generalized to allow defining an agent without reference to an existing routine (such as my_action, my_condition, action2), through inline agents as in

 my_list.do_all (agent (s: STRING) require not_void: s /= Void do s.append_character (',') ensure appended: s.count = old s.count + 1 end) 

The inline agent passed here can have all the trappings of a normal routine, including precondition, postcondition, rescue clause (not used here), and a full signature. This avoids defining routines when all that's needed is a computation to be wrapped in an agent. This is useful in particular for contracts, as in an invariant clause that expresses that all elements of a list are positive:

 my_list.for_all (agent (x: INTEGER): BOOLEAN do Result := (x > 0) end) 

The current agent mechanism leaves a possibility of run-time type error (if a routine with n arguments is passed to an agent expecting m arguments with m < n). This can be avoided by a run-time check through the precondition valid_arguments of call. Several proposals for a purely static correction of this problem are available, including a language change proposal by Ribet et al.[5].


Once routines

A routine's result can be cached using the once keyword in place of do. Non-first calls to a routine require no additional computation or resource allocation, but simply return a previously computed result. A common pattern for "once functions" is to provide shared objects; the first call will create the object, subsequent ones will return the reference to that object. The typical scheme is:

 shared_object: SOME_TYPE once create Result.make (args) -- This creates the object and returns a reference to it through `Result'. end 

The returned object—Result in the example—can itself be mutable, but its reference remains the same.


Often "once routines" perform a required initialization: multiple calls to a libraries can include a call to the initialization procedure, but only the first such call will perform the required actions. Using this pattern initialization can be decentralized, avoiding the need for a special initialization module. "Once routines" are similar in purpose and effect to the singleton pattern in many programming languages, and to the Borg pattern used in Python. In software engineering, the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. ... In software engineering, the singleton pattern is a design pattern that is used to restrict instantiation of a class to one object. ...


The ECMA specification allows variants of "once" (qualified by a keyword in parentheses, e.g. once (THREAD): once per process, once per thread, once per object. However, this is not yet fully implemented by current compilers (typically, only PROCESS and THREAD).


Conversions

Eiffel provides a mechanism to allow conversions between various types. The mechanisms coexists with inheritance and complements it. To avoid any confusion between the two mechanisms, the design enforces the following principle:

(Conversion principle) A type may not both conform and convert to another.

For example NEWSPAPER may conform to PUBLICATION, but INTEGER converts to REAL (and does not inherit from it).


The conversion mechanism simply generalizes the ad hoc conversion rules (such as indeed between INTEGER and REAL) that exist in most programming languages, making them applicable to any type as long as the above principle is observed. For example a DATE class may be declared to convert to STRING; this makes it possible to create a string from a date simply through

 my_string := my_date 

as a shortcut for using an explicit object creation with a conversion procedure:

 create my_string.make_from_date (my_date) 

To make the first form possible as a synonym for the second, it suffices to list the creation procedure (constructor) make_from_date in a convert clause at the beginning of the class.


As another example, if there is such a conversion procedure listed from TUPLE [day: INTEGER; month: STRING; year: INTEGER], then one can directly assign a tuple to a date, causing the appropriate conversion, as in

 Bastille_day := [14, "July", 1789] 

Exception handling

Exception handling in Eiffel is based on Design by Contract. For example, an exception occurs when a routine's caller did not satisfy a precondition or when the routine itself cannot ensure its promised postcondition. Exception handling is a programming language construct or computer hardware mechanism designed to handle the occurrence of some condition that changes the normal flow of execution. ...


Unlike other languages, it is not common practice in Eiffel to use exceptions for control flow, nor to correct mistakes in input data. In computer science control flow (or alternatively, flow of control) refers to the order in which the individual statements, instructions or function calls of an imperative or functional program are executed or evaluated. ...


An exception handler is defined using the rescue keyword. Within the rescue section, the retry keyword executes the routine again. For example, the following routine tracks the number of attempts at executing the routine, and only retries a certain number of times:

 connect_to_server (server: SOCKET) -- Connect to a server or give up after 10 attempts. require server /= Void and then server.address /= Void local attempts: INTEGER do server.connect ensure connected: server.is_connected rescue if attempts < 10 then attempts := attempts + 1 retry end end 

This example is arguably flawed for anything but the simplest programs, however, because connection failure is to be expected. For most programs a routine name like attempt_connecting_to_server would be better, and the postcondition would not promise a connection, leaving it up to the caller to take appropriate steps if the connection was not opened.


Concurrency

A number of networking and threading libraries are available, such as EiffelNet and EiffelThreads. A concurrency model for Eiffel, based on the concepts of Design by Contract, is SCOOP (software), or Simple Concurrent Object-Oriented Programming, not yet part of the official language definition but available as an add-on from ETH Zurich. Scoop is a content management system originally developed by Rusty Foster. ... The ETH Zurich, often called Swiss Federal Institute of Technology, is a science and technology university in the city of Zurich, Switzerland. ...


Operator and bracket syntax, assigner commands

Eiffel's view of computation is completely object-oriented in the sense that every operation is relative to an object, the "target". So for example an addition

 [1] a + b 

is conceptually understood as if it were a function call

 [2] a.plus (b) 

with target a, feature plus and argument b.


Of course [2] is the conventional syntax and usually preferred. Operator syntax makes it possible to use either form by declaring the feature (for example in INTEGER, but this applies to other basic classes and can be used in any other for which such an operator appropriate):

 plus alias "+" (other: INTEGER): INTEGER -- ... Normal function declaration... end 

The range of operators that can be used as "alias" is quite broad; they include predefined operators such as "+" but also "free operators" made of non-alphanumeric symbols. This makes it possible to design special infix and prefix notations, for example in mathematics and physics applications.


Every class may in addition have one function aliased to "[]", the "bracket" operator, allowing the notation a [i, ...] as a synonym for a.f (i, ...) where f is the chosen function. This is particularly useful for container structures such as arrays, hash tables, lists etc. For example access to an element of a hash table with string keys can be written

 number := phone_book ["JILL SMITH"] 

"Assigner commands" are a companion mechanism designed in the same spirit of allowing well-established, convenient notation reinterpreted in the framework of object-oriented programming. Assigner commands allow assignment-like syntax to call "setter" procedures. An assignment proper can never be of the form a.x := v as this violates information hiding; you have to go for a setter command (procedure). For example the hash table class can have the function and the procedure

 item alias "[]" (key: STRING): ELEMENT [3] -- The element of key `key'. -- ("Getter" query) do ... end put (e: ELEMENT; key: STRING) -- Insert the element `e', associating it with the key `key'. -- ("Setter" command) do ... end 

Then to insert an element you have to use an explicit call to the setter command:

 [4] phone_book.put (New_person, "JILL SMITH") 

It is possible to write this equivalently as

 [5] phone_book ["JILL SMITH"] := New_person 

(in the same way that phone_book ["JILL SMITH"] is a synonym for number := phone_book.item ("JILL SMITH")), provided the declaration of item now starts (replacement for [3]) with

 item alias "[]" (key: STRING): ELEMENT assign put 

This declares put as the assigner command associated with item and, combined with the bracket alias, makes [5] legal and equivalent to [4]. (It could also be written, without taking advantage of the bracket, as phone_book.item ("JILL SMITH") := New_person.


note: The argument list of a's assigner is constrained to be: (a's return type;all of a's argument list...)


Lexical and syntax properties

Eiffel is not case-sensitive. The tokens make, maKe and MAKE all denote the same identifier. See, however, the "style rules" below.


Comments are introduced by -- (two consecutive dashes) and extend to the end of the line.


The semicolon, as instruction separator, is optional. Most of the time the semicolon is just omitted, except to separate multiple instructions on a line. This results in less clutter on the program page.


There is no nesting of feature and class declarations. As a result the structure of an Eiffel class is simple: some class-level clauses (inheritance, invariant) and a succession of feature declarations, all at the same level.


It is customary to group features into separate "feature clauses" for more readability, with a standard set of basic feature tags appearing in a standard order, for example:

 class HASH_TABLE [ELEMENT, KEY -> HASHABLE] inherit TABLE [ELEMENT] feature -- Initialization -- ... Declarations of initialization commands (creation procedures/constructors) ... feature -- Access -- ... Declarations of non-boolean queries on the object state, e.g. item ... feature -- Status report -- ... Declarations of boolean queries on the object state, e.g. is_empty ... feature -- Element change -- ... Declarations of commands that change the structure, e.g. put ... -- etc. end 

In contrast to most curly bracket programming languages, Eiffel makes a clear distinction between expressions and instructions. This is in line with the Command-Query Separation principle of the Eiffel method. Curly brace or bracket programming languages are those which use balanced brackets ({ and }, also known as brace brackets or simply braces) to make blocks in their syntax or formal grammar, mainly due to being C-influenced. ... Command-query separation (CQS) is a principle of object-oriented computer programming. ...


Style conventions

Much of the documentation of Eiffel uses distinctive style conventions, designed to enforce a consistent look-and-feel. Some of these conventions apply to the code format itself, and others to the standard typographic rendering of Eiffel code in formats and publications where these conventions are possible.


While the language is case-insensitive, the style standards prescribe the use of all-capitals for class names (LIST), all-lower-case for feature names (make), and initial capitals for constants (Avogadro). The recommended style also suggests underscore to separate components of a multi-word identifier, as in average_temperature.


The specification of Eiffel includes guidelines for displaying software texts in typeset formats: keywords in bold, user-defined identifiers and constants are shown in italics, comments, operators, and punctuation marks in Roman, with program text in blue as in the present article to distinguish it from explanatory text. For example, the "Hello, world!" program given above would be rendered as below in Eiffel documentation:

 class HELLO_WORLD create make feature make do io.put_string ("Hello, world!") io.put_new_line end end 

Interfaces to other tools and languages

Eiffel is a purely object-oriented language but provides an open architecture for interfacing with "external" software in any other programming language.


It is possible for example to program machine- and operating-system level operations in C. Eiffel provides a straightforward interface to C routines, including support for "inline C" (writing the body of an Eiffel routine in C, typically for short machine-level operations). C is a general-purpose, block structured, procedural, imperative computer programming language developed in 1972 by Dennis Ritchie at the Bell Telephone Laboratories for use with the Unix operating system. ...


Although there is no direct connection between Eiffel and C, all of the current Eiffel compilers except one (Visual Eiffel) output C source code as an intermediate language, to submit to a C compiler, for optimizing and portability. On .NET, the EiffelStudio compiler directly generates CIL (Common Intermediate Language) code for the .NET virtual machine. The SmartEiffel compiler can also output Java bytecode. A diagram of the operation of a typical multi-language, multi-target compiler. ... Visual Eiffel is an implementation of the Eiffel programming language developed and distributed by Object Tools GmbH, a German company. ... Source code (commonly just source or code) is any series of statements written in some human-readable computer programming language. ... In computer science, an intermediate language is the language of an abstract machine designed to aid in the analysis of computer programs. ... In computing, optimization is the process of modifying a system to make some aspect of it work more efficiently or use fewer resources. ... In computer science, porting is the process of adapting software so that an executable program can be created for a computing environment that is different from the one for which it was originally designed (e. ... EiffelStudio is a development environment for the Eiffel programming language developed and distributed by Eiffel Software. ... {{Infobox_Software | name = SmartEiffel | screenshot = | caption = | developer = The SmartEiffel Team | latest_release_version = 2. ... Java bytecode is the form of instructions that the Java virtual machine executes. ...


References

  1. ^ Object-Oriented Software Construction, Second Edition, by Bertrand Meyer, Prentice Hall, 1997, ISBN 0-13-629155-4
  2. ^ ECMA International: Standard ECMA-367 —Eiffel: Analysis, Design and Programming Language 2nd edition (June 2006); available online at www.ecma-international.org/publications/standards/Ecma-367.htm
  3. ^ International Organisation for Standardisation: Standard ISO/IEC DIS 25436, available online at [1]
  4. ^ Bertrand Meyer: Overloading vs Object Technology, in Journal of Object-Oriented Programming (JOOP), vol. 14, no. 4, October-November 2001, available online
  5. ^ Philippe Ribet, Cyril Adrian, Olivier Zendra, Dominique Colnet: Conformance of agents in the Eiffel language, in Journal of Object Technology, vol. 3, no. 4, April 2004, Special issue: TOOLS USA 2003, pp. 125-143. Available on line from the JOT article page

Bertrand Meyer (born 1950 in France) developed the Eiffel programming language, and is an author, academic and consultant in the field of computer languages. ...

External links

  • Basic Eiffel Language Mechanisms, Bertrand Meyer, August 2006.
  • Eiffel Software's Open Source initiative
  • Eiffel Software web site of the company that introduced Eiffel, was Interactive Software Engineering (ISE).
  • Eiffel tutorial (100 pages) by Bertrand Meyer (HTML, PDF)
  • Eiffel standard, revision 2 (2006); this is the ECMA standard, with free access, its text identical to that of the ISO standard.
  • SmartEiffel fairly complete Eiffel compiler, released under GNU GPL license, was SmallEiffel, not ECMA standard compliant.
  • Visual Eiffel an open source implementation of Eiffel creating native code for X86 systems (Windows, Linux)
  • NICE Nonprofit International Consortium for Eiffel.
  • eiffelroom.com Community around standard Eiffel
  • eiffelzone.com Includes a comprehensive Eiffel Software Directory
  • Cetus Eiffel Page
  • Eiffel for .Net
  • Eiffel: the Language subset
Bertrand Meyer (born 1950 in France) developed the Eiffel programming language, and is an author, academic and consultant in the field of computer languages. ... Open source refers to projects that are open to the public and which draw on other projects that are freely available to the general public. ... A system of codes directly understandable by a computers CPU is termed this CPUs native or machine language. ...

  Results from FactBites:
 
Eiffel (programming language) - Wikipedia, the free encyclopedia (3946 words)
Eiffel is a purely object-oriented language but provides an open architecture for interfacing with "external" software in any other programming language.
Although there is no direct connection between Eiffel and C, all of the current Eiffel compilers except one (Visual Eiffel) output C source code as an intermediate language, to submit to a C compiler, for optimizing and portability.
Eiffel standard, revision 2 (2006); this is the ECMA standard, with free access, its text identical to that of the ISO standard.
Introduction to Eiffel (3274 words)
With roots in Simula, beholden to no backwards compatibility issues, the Eiffel programming language was designed from scratch by Bertrand Meyer and his colleagues for the purpose of enabling the construction of robust, general, reusable software components.
Eiffel is available or announced from a number of vendors on a roster of operating systems or platforms including Windows 3.1, VMS, SunOS, Solaris, Ultrix, OSF/1, DG Aviion, IBM RS/6000, Silicon Graphics, Macintosh, OS-2, and NEXTSTEP, as well as Linux.
Such a package, written in a programming language is a class, but an instance of a class in execution (or in storage) is an object.
  More results at FactBites »

 
 

COMMENTARY     


Share your thoughts, questions and commentary here
Your name
Your comments

Want to know more?
Search encyclopedia, statistics and forums:

 


Press Releases |  Feeds | Contact
The Wikipedia article included on this page is licensed under the GFDL.
Images may be subject to relevant owners' copyright.
All other elements are (c) copyright NationMaster.com 2003-5. All Rights Reserved.
Usage implies agreement with terms, 1022, m