mirror of
https://github.com/EiffelSoftware/eiffel-org.git
synced 2026-02-08 11:34:45 +01:00
Author:admin
Date:2008-09-19T07:54:43.000000Z git-svn-id: https://svn.eiffel.com/eiffel-org/trunk@25 abb3cda0-5349-4a8f-a601-0c33ac3a8c38
This commit is contained in:
jfiat
@@ -1,6 +1,7 @@
|
||||
[[Property:title|11 Agents]]
|
||||
[[Property:link_title|ET: Agents]]
|
||||
[[Property:weight|-3]]
|
||||
[[Property:uuid|ba49a80d-5ddf-8b30-4943-528974fd0ddd]]
|
||||
Our last mechanism, agents, adds one final level of expressive power to the framework describe so far. Agents apply object-oriented concepts to the modeling of operations.
|
||||
|
||||
==Objects for operations==
|
||||
|
||||
@@ -9,11 +9,11 @@ Eiffel directly implements the ideas of Design by Contract™ , which enhance
|
||||
A system -- a software system in particular, but the ideas are more general -- is made of a number of cooperating components. Design by Contract™ states that their cooperation should be based on precise specifications -- contracts -- describing each party's expectations and guarantees.
|
||||
|
||||
An Eiffel contract is similar to a real-life contract between two people or two companies, which it is convenient to express in the form of tables listing the expectations and guarantees. Here for example is how we could sketch the contract between a homeowner and the telephone company:
|
||||
{|
|
||||
{| border="1"
|
||||
|-
|
||||
| <code>provide_service</code>|| style="width=10%;"
|
||||
| '''OBLIGATIONS'''|| style="width=35%;"
|
||||
| '''BENEFITS'''|| style="width=35%;"
|
||||
| <code>provide_service</code>|| style="width=10%"
|
||||
| '''OBLIGATIONS'''|| style="width=35%"
|
||||
| '''BENEFITS'''|| style="width=35%"
|
||||
|-
|
||||
| '''Client'''
|
||||
| (Satisfy precondition:) <br/>
|
||||
@@ -93,7 +93,7 @@ The precondition of a routine expresses conditions that the routine is imposing
|
||||
The postcondition of a routine expresses what the routine guaranteed to its clients for calls satisfying the precondition. The notation <code> old expression </code>, valid in postconditions ( <code> ensure </code> clauses) only, denotes the value that <code> expression </code> had on entry to the routine.
|
||||
|
||||
The precondition and postcondition state the terms of the contract between the routine and its clients, similar to the earlier example of a human contract:
|
||||
{|
|
||||
{| border="1"
|
||||
|-
|
||||
| <code>deposit</code>|| style="width=10%;"
|
||||
| '''OBLIGATIONS'''|| style="width=35%;"
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|6 The Dynamic Structure: Execution Model]]
|
||||
[[Property:link_title|ET: The Dynamic Structure: Execution Model]]
|
||||
[[Property:weight|-10]]
|
||||
[[Property:uuid|1f3f2707-9129-4dca-76c7-157143d7ae74]]
|
||||
A system with a certain static structure describes a set of possible executions. The run-time model governs the structure of the data ( <code> objects </code>) created during such executions.
|
||||
|
||||
The properties of the run-time model are not just of interest to implementers; they also involve concepts directly relevant to the needs of system modelers and analysts at the most abstract levels.
|
||||
|
||||
@@ -0,0 +1,35 @@
|
||||
[[Property:title|Eiffel Tutorial Copyright]]
|
||||
[[Property:link_title|ET: Eiffel Tutorial Copyright]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|105e9956-f168-b060-a6be-e78b221f269a]]
|
||||
====MANUAL IDENTIFICATION AND COPYRIGHT====
|
||||
|
||||
Title: An Eiffel Tutorial, Eiffel Software Technical Report TR-EI-66/TU.
|
||||
|
||||
Publication history
|
||||
|
||||
First published July 2001. Corresponds to release 5.0 of the EiffelStudio environment.
|
||||
|
||||
Author
|
||||
|
||||
Software credits
|
||||
|
||||
See acknowledgments in book <span> [http://www.eiffel.com/doc/page.html Eiffel: The Language] </span>.
|
||||
|
||||
Cover design
|
||||
|
||||
Rich Ayling.
|
||||
|
||||
Copyright notice and proprietary information
|
||||
|
||||
Copyright Interactive Software Engineering Inc. (Eiffel Software), 2001. May not be reproduced in any form (including electronic storage) without the written permission of Eiffel Software . "Eiffel Power" and the Eiffel Power logo are trademarks of Eiffel Software .
|
||||
|
||||
All uses of the product documented here are subject to the terms and conditions of the Eiffel Software Eiffel user license. Any other use or duplication is a violation of the applicable laws on copyright, trade secrets and intellectual property.
|
||||
|
||||
Special duplication permission for educational institutions
|
||||
|
||||
Degree-granting educational institutions using Eiffel Software Eiffel for teaching purposes as part of the <span> [http://www.eiffel.com/educators/resources.html Eiffel University Partnership Program] </span> may be permitted under certain conditions to copy specific parts of this book. Contact Eiffel Software for details.
|
||||
|
||||
|
||||
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|2 General Properties]]
|
||||
[[Property:link_title|ET: General Properties]]
|
||||
[[Property:weight|-14]]
|
||||
[[Property:uuid|1ad0b1d5-7ac6-9f55-92ec-ba6f42aee690]]
|
||||
Here is an overview of the facilities supported by Eiffel: <br/>
|
||||
* Completely ''object-oriented'' approach. Eiffel is a full-fledged application of object technology, not a "hybrid" of O-O and traditional concepts.
|
||||
* ''External interfaces''. Eiffel is a software composition tool and is easily interfaced with software written in such languages as C, C++, Java and C#.
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|7 Genericity and Arrays]]
|
||||
[[Property:link_title|ET: Genericity and Arrays]]
|
||||
[[Property:weight|-9]]
|
||||
[[Property:uuid|7f3bd1d7-357e-031d-9faa-b00594aa9ae0]]
|
||||
Some of the classes that we will need, particularly in libraries, are '''container''' classes, describing data structures made of a number of objects of the same or similar types. Examples of containers include arrays, stacks and lists. The class <code> DEPOSIT_LIST </code> posited in earlier examples describes containers.
|
||||
|
||||
It is not hard, with the mechanisms seen so far, to write the class <code> DEPOSIT_LIST </code>, which would include such features as <code> count </code> (query returning the number of deposit objects in the list) and <code> put </code> (command to insert a new deposit object).
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|4 Hello World]]
|
||||
[[Property:link_title|ET: Hello World]]
|
||||
[[Property:weight|-12]]
|
||||
[[Property:uuid|5b286f94-dd63-1169-a64e-74b5f8c5ef14]]
|
||||
When discovering any approach to software construction, however ambitious its goals, it is reassuring to see first a small example of the big picture -- a complete program to print the famous "Hello World" string. Here is how to perform this fascinating task in the Eiffel notation.
|
||||
|
||||
You write a class <code> HELLO </code> with a single procedure, say <code> make </code>, also serving as creation procedure. If you like short texts, here is a minimal version:
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|9 Inheritance]]
|
||||
[[Property:link_title|ET: Inheritance]]
|
||||
[[Property:weight|-7]]
|
||||
[[Property:uuid|c90e6ee3-b39d-48e5-2321-a34e12fd5327]]
|
||||
Inheritance is a powerful and attractive technique. A look at either the practice or literature shows, however, that it is not always well applied. Eiffel has made a particular effort to tame inheritance for the benefit of modelers and software developers. Many of the techniques are original with Eiffel. Paul Dubois has written (comp.lang.python Usenet newsgroup, 23 March 1997): there are two things that [Eiffel] got right that nobody else got right anywhere else: support for design by contract, and multiple inheritance. Everyone should understand these "correct answers" if only to understand how to work around the limitations in other languages.
|
||||
|
||||
==Basic inheritance structure==
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|13 To Learn More]]
|
||||
[[Property:link_title|ET: To Learn More]]
|
||||
[[Property:weight|-1]]
|
||||
[[Property:uuid|74a5c826-8f21-8cf2-4f2c-dee4ee28ead5]]
|
||||
Beyond this introduction, you will find the following two books essential to a mastery of the method and language: <br/>
|
||||
* <span> [http://eiffel.com/doc/oosc/ Object-Oriented Software Construction] </span>, Bertrand Meyer, Prentice Hall, 2nd edition 1997. (Make sure to get the second edition.) About object technology in general; presents the method behind Eiffel.
|
||||
* <span> [http://eiffel.com/doc/ Eiffel: The Language] </span>, Bertrand Meyer, Prentice Hall, 1992. Language manual and reference.
|
||||
|
||||
@@ -1,12 +1,13 @@
|
||||
[[Property:title|12 Lexical Conventions and Style Rules]]
|
||||
[[Property:link_title|ET: Lexical Conventions and Style Rules]]
|
||||
[[Property:weight|-2]]
|
||||
[[Property:uuid|60fdf029-8626-166d-cc4f-9069aacdda7f]]
|
||||
Eiffel software texts are free-format: distribution into lines is not semantically significant, and any number of successive space and line-return characters is equivalent to just one space. The style rules suggest indenting software texts as illustrated by the examples in this chapter.
|
||||
|
||||
Successive declarations or instructions may be separated by semicolons. Eiffel's syntax has been so designed, however, that (except in rare cases) '''the semicolon is optional'''. Omitting semicolons for elements appearing on separate lines lightens text and is the recommended practice since semicolons, as used by most programming languages, just obscure the text by distracting attention from the actual contents. Do use semicolons if you occasionally include successive elements on a single line.
|
||||
|
||||
63 names -- all unabbreviated single English words, except for <code> elseif </code> which is made of two words -- are reserved, meaning that you cannot use them to declare new entities. Here is the list:
|
||||
{|
|
||||
{| border="1"
|
||||
|-
|
||||
| <code>agent</code>
|
||||
| <code>alias</code>
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|10 Other Mechanisms]]
|
||||
[[Property:link_title|ET: Other Mechanisms]]
|
||||
[[Property:weight|-4]]
|
||||
[[Property:uuid|c0a01664-194c-4e84-0517-8e7c1ca61dec]]
|
||||
We now examine a few important mechanisms that complement the preceding picture: shared objects; constants; instructions; and lexical conventions.
|
||||
|
||||
==Once routines and shared objects==
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|1 Overview]]
|
||||
[[Property:link_title|ET: Overview]]
|
||||
[[Property:weight|-15]]
|
||||
[[Property:uuid|0eaddff9-5d72-87fc-663a-2fc8a9152c25]]
|
||||
Eiffel is a method and language for the efficient description and development of quality systems.
|
||||
|
||||
As a language, Eiffel is more than a programming language. It covers not just programming in the restricted sense of implementation but the whole spectrum of software development: <br/>
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|3 The Software Process in Eiffel]]
|
||||
[[Property:link_title|ET: The Software Process in Eiffel]]
|
||||
[[Property:weight|-13]]
|
||||
[[Property:uuid|eef7f31a-25de-93cc-9a33-41d991c51ccb]]
|
||||
Eiffel, as noted, supports the entire lifecycle. The underlying view of the system development lifecycle is radically different not only from the traditional "Waterfall" model (implying a sequence of discrete steps, such as analysis, global design, detailed design, implementation, separated by major changes of method and notation) but also from its more recent variants such as the spiral model or "rapid prototyping", which remain predicated on a synchronous, full-product process, and retain the gaps between successive steps.
|
||||
|
||||
Clearly, not everyone using Eiffel will follow to the letter the principles outlined below; in fact, some highly competent and successful Eiffel developers may disagree with some of them and use a different process model. In the author's mind, however, these principles fit best with the language and the rest of the method, even if practical developments may fall short of applying their ideal form.
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|5 The Static Picture: System Organization]]
|
||||
[[Property:link_title|ET: The Static Picture: System Organization]]
|
||||
[[Property:weight|-11]]
|
||||
[[Property:uuid|46d3f41e-d41c-a443-4574-403dfebb60aa]]
|
||||
We now look at the overall organization of Eiffel software.
|
||||
|
||||
References to Eiffel Software's libraries appearing in subsequent examples include: '''EiffelBase''', the fundamental open-source library covering data structures and algorithms; the '''kernel library''', a subset of EiffelBase covering the most basic notions such as arrays and strings; and '''EiffelVision 2''', an advanced graphics and GUI library providing full compatibility across platforms (Unix, Windows, OpenVMS) with native look-and-feel on each.
|
||||
|
||||
@@ -2,5 +2,5 @@
|
||||
[[Property:link_title|Tutorial]]
|
||||
[[Property:weight|2]]
|
||||
[[Property:uuid|4dbc41e2-ecfc-8c50-9288-fce30f4abd90]]
|
||||
From this tutorial you should get a solid understanding of what Eiffel is all about and why it is different from other technologies. Still more detail is available in [http://www.eiffel.com/doc/oosc/ Object-oriented Software Construction, 2nd Edition].
|
||||
From this tutorial you should get a broad understanding of what Eiffel is all about and why it is different from other technologies. Still more detail is available in [http://www.eiffel.com/doc/oosc/ Object-oriented Software Construction, 2nd Edition].
|
||||
|
||||
|
||||
@@ -6,10 +6,11 @@
|
||||
|
||||
Here you can learn about the Eiffel development method and Eiffel the language.
|
||||
|
||||
At the heart of the Eiffel Development Framework is the Eiffel method. Everything else, the language, the tools, the libraries exist because of the method. The method is laid out in detail in [http://www.eiffel.com/doc/oosc/ Object-oriented Software Construction, 2nd Edition]. But you will find some introductory material here. An "invitation" to Eiffel which is fairly short, and a tutorial which is more detailed.
|
||||
At the heart of the Eiffel Development Framework is the Eiffel method. Everything else, the language, the tools, the libraries exist because of the method.
|
||||
|
||||
In order for us to communicate effectively about the activities of the method we must some way to record the products of those activities. That is what Eiffel the language does for us ... with the added benefit that, ultimately, we implement whole running software systems in the language.
|
||||
In order for us to communicate effectively about the activities of the method we must have some way to record the products of those activities. That is what Eiffel the language does for us ... with the added benefit that, ultimately, we implement whole running software systems in the language.
|
||||
|
||||
The method is laid out in wonderful detail in [http://www.eiffel.com/doc/oosc/ Object-oriented Software Construction, 2nd Edition]. But, if you're just getting started, you will find some good introductory material on this page. The invitation to Eiffel is fairly short introduction to the method and language. and the tutorial gives a more detailed look.
|
||||
|
||||
|
||||
* An [[Invitation to Eiffel|Invitation to Eiffel]]
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|12 Combining Genericity and Inheritance]]
|
||||
[[Property:link_title|I2E: Combining Genericity and Inheritance]]
|
||||
[[Property:weight|-3]]
|
||||
[[Property:uuid|912e4c38-9add-e478-59c3-5c10aa75d784]]
|
||||
Genericity and inheritance, the two fundamental mechanisms for generalizing classes, may be combined in two fruitful ways.
|
||||
|
||||
The first technique yields '''polymorphic data structures'''. Assume that in the generic class <code> LIST [ G ] </code> the insertion procedure <code> put </code> has a formal argument of type <code> G </code>, representing the element to be inserted. Then with a declaration such as
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|13 Deferred Classes and Seamless Development]]
|
||||
[[Property:link_title|I2E: Deferred Classes and Seamless Development]]
|
||||
[[Property:weight|-2]]
|
||||
[[Property:uuid|b3264238-f160-a6fc-0b03-adcd80b1f55a]]
|
||||
The inheritance mechanism includes one more major notion: deferred features and classes.
|
||||
|
||||
Declaring a feature <code> f </code> as deferred in a class <code> C </code> expresses that there is no default implementation of <code> f </code> in <code> C </code>; such implementations will appear in eventual descendants of <code> C </code>. A class that has one or more deferred routines is itself said to be deferred. A non-deferred routine or class -- like all those seen until now -- is said to be '''effective'''.
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|6 Design by Contract and Assertions]]
|
||||
[[Property:link_title|I2E: Design by Contract and Assertions]]
|
||||
[[Property:weight|-9]]
|
||||
[[Property:uuid|f563aa75-3a5a-5110-b4f1-07da5448f668]]
|
||||
If classes are to deserve their definition as abstract data type implementations, they must be known not just by the available operations, but also by the formal properties of these operations, which did not yet appear in the preceding example.
|
||||
|
||||
==The role of assertions==
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|2 Design Principles]]
|
||||
[[Property:link_title|I2E: Design Principles]]
|
||||
[[Property:weight|-13]]
|
||||
[[Property:uuid|529659bd-ec13-5805-87f2-2fd9318ad442]]
|
||||
The aim of Eiffel is to help specify, design, implement and modify quality software. This goal of quality in software is a combination of many factors; the language design concentrated on the three factors which, in the current state of the industry, are in direct need of improvements: reusability, extendibility and reliability. Also important were other factors such as efficiency, openness and portability.
|
||||
|
||||
'''Reusability''' is the ability to produce components that may serve in many different applications. Central to the Eiffel approach is the presence of predefined libraries such as EiffelBase, and the language's support for the production of new libraries.
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|8 Event-Driven Programming and Agents]]
|
||||
[[Property:link_title|I2E: Event-Driven Programming and Agents]]
|
||||
[[Property:weight|-7]]
|
||||
[[Property:uuid|16fdab60-ae42-1bb8-f4bb-89e34d18a842]]
|
||||
The division of roles in object technology is clear: of the two principal constituents of a system, object types and operations, the first dominates. Classes, representing object types, determines the structure of the software; every routine, representing an operations, belongs to a class.
|
||||
|
||||
In some circumstances it is useful to define an object that denotes an operation. This is especially useful if you want to build an object structure that refers to operations, so that you can later traverse the structure and execute the operations encountered. A typical application is '''event-driven programming''' for Graphical User Interfaces (GUI), including Web programming. In GUI programming you will want to record properties of the form
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|7 Exceptions]]
|
||||
[[Property:link_title|I2E: Exceptions]]
|
||||
[[Property:weight|-8]]
|
||||
[[Property:uuid|e3e10dac-0dd7-bbe1-240c-6a6985c7376a]]
|
||||
Whenever there is a contract, the risk exists that someone will break it. This is where exceptions come in.
|
||||
|
||||
Exceptions -- contract violations -- may arise from several causes. One is an assertion violation, if you've selected run-time assertion monitoring. Another is a signal triggered by the hardware or operating system to indicate an abnormal condition such as arithmetic overflow, or an attempt to create a new object when there's not enough memory available.
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|9 Genericity]]
|
||||
[[Property:link_title|I2E: Genericity]]
|
||||
[[Property:weight|-6]]
|
||||
[[Property:uuid|091c0b65-73de-b454-b3f2-d8752983780e]]
|
||||
Building software components (classes) as implementations of abstract data types yields systems with a solid architecture but does not in itself ensure reusability and extendibility. Two key techniques address the problem: generosity (unconstrained or constrained) and inheritance. Let us look first at the unconstrained form.
|
||||
|
||||
To make a class generic is to give it '''formal generic parameters''' representing as unknown types, as in these examples from EiffelBase, an open-source library covering basic data structures and algorithms:
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|10 Inheritance]]
|
||||
[[Property:link_title|I2E: Inheritance]]
|
||||
[[Property:weight|-5]]
|
||||
[[Property:uuid|acf84989-0e7c-f2f7-427a-19e7fce404ce]]
|
||||
Inheritance, the other fundamental generalization mechanism, makes it possible to define a new class by combination and specialization of existing classes rather than from scratch.
|
||||
|
||||
The following simple example, from the Data Structure Library in EiffelBase, is typical. <code> LIST </code>, as noted, describes lists in any representation. One such representation if the lists have a fixed number of elements uses an array. We may define the corresponding class by combination of <code> LIST </code> and <code> ARRAY </code>, as follows:
|
||||
|
||||
@@ -0,0 +1,38 @@
|
||||
[[Property:title|Invitation to Eiffel Copyright]]
|
||||
[[Property:link_title|I2E: Invitation to Eiffel Copyright]]
|
||||
[[Property:weight|0]]
|
||||
[[Property:uuid|ce7b4af4-b669-9fec-92e1-c24c4f089336]]
|
||||
Title: Invitation to Eiffel, Eiffel Software Technical Report TR-EI-67/IV.
|
||||
|
||||
==Publication history==
|
||||
First published 1987. Some revisions (in particular Web versions) have used the title "Eiffel in a Nutshell" <br/>
|
||||
This version: July 2001. Introduces coverage of agents; several other improvements. Corresponds to release 5.0 of the EiffelStudio environment.
|
||||
==Author==
|
||||
Bertrand Meyer
|
||||
==Software Credits==
|
||||
See acknowledgments in book [http://www.eiffel.com/doc/page.html Eiffel: The Language] .
|
||||
==Cover Design==
|
||||
Rich Ayling.
|
||||
==Copyright notice and proprietary information==
|
||||
Copyright Interactive Software Engineering Inc. (Eiffel Software), 2001. May not be reproduced in any form (including electronic storage) without the written permission of Eiffel Software . "Eiffel Power" and the Eiffel Power logo are trademarks of Eiffel Software . All uses of the product documented here are subject to the terms and conditions of the Eiffel Software Eiffel user license. Any other use or duplication is a violation of the applicable laws on copyright, trade secrets and intellectual property.
|
||||
==Special duplication permission for educational institutions==
|
||||
Degree-granting educational institutions using Eiffel Software Eiffel for teaching purposes as part of the [http://www.eiffel.com/educators/resources.html Eiffel University Partnership Program] may be permitted under certain conditions to copy specific parts of this book. Contact Eiffel Software for details.
|
||||
{{info|About Eiffel Software (Interactive Software Engineering) helps you produce software better, faster and cheaper. Eiffel Software provides a wide range of products and services based on object technology, including Eiffel Software Eiffel, a complete development environment for the full system life cycle. Eiffel Software's training courses, available worldwide, cover key management and technical topics. Eiffel Software's consultants are available to address your project needs at all levels. Eiffel Software's TOOLS (Technology of Object-Oriented Languages and Systems) conferences, [http://www.tools-conferences.com http://www.tools-conferences.com] , are the meeting point for anyone interested in the software technologies of the future. Eiffel Software originated one of the earliest . NET products and offers a full range of . NET services and training at [http://www.dotnetexperts.com http://www.dotnetexperts.com] . }}
|
||||
|
||||
==For more information==
|
||||
Interactive Software Engineering Inc. <br/>
|
||||
Eiffel Software Building, <br/>
|
||||
356 Storke Road, <br/>
|
||||
Goleta, <br/>
|
||||
CA, 93117 <br/>
|
||||
USA. <br/>
|
||||
<br/>
|
||||
Telephone 805-685-1006, <br/>
|
||||
Fax 805-685-6869
|
||||
==Internet and email==
|
||||
Eiffel Software maintains a rich source of information at [http://eiffel.com http://eiffel.com] , with more than 1200 Web pages including online documentation, downloadable files, product descriptions, links to Eiffel Software partners, University Partnership program, mailing list archives, announcements, press coverage, Frequently Asked Questions, Support pages, and much more. Visit [http://www.eiffel.com/general/contact_details.html http://www.eiffel.com/general/contact_details.html] to request information about products and services. To subscribe to the Eiffel Software Eiffel user list, go to [http://groups.eiffel.com/join http://groups.eiffel.com/join] .
|
||||
==Support programs==
|
||||
Eiffel Software offers a variety of support options tailored to the diverse needs of its customers. See [http://support.eiffel.com http://support.eiffel.com] for details.
|
||||
|
||||
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|3 Object-Oriented Design]]
|
||||
[[Property:link_title|I2E: Object-Oriented Design]]
|
||||
[[Property:weight|-12]]
|
||||
[[Property:uuid|e0a1f24e-5dd7-e5f8-8be8-8da32cc6a91c]]
|
||||
To achieve reusability, extendibility and reliability, the principles of object-oriented design provide the best known technical answer.
|
||||
|
||||
An in-depth discussion of these principles fall beyond the scope of this introduction but here is a short definition:
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|11 Polymorphism and Dynamic Binding]]
|
||||
[[Property:link_title|I2E: Polymorphism and Dynamic Binding]]
|
||||
[[Property:weight|-4]]
|
||||
[[Property:uuid|1c3221be-0237-1c9a-407d-652a4084de12]]
|
||||
Inheritance is not just a module combination and enrichment mechanism. It also enables the definition of flexible entities that may become attached to objects of various forms at run time, a property known as polymorphism.
|
||||
|
||||
This remarkable facility must be reconciled with static typing. The language convention is simple: an assignment of the form <code> a </code> <code> : </code> <code> b </code> is permitted not only if <code> a </code> and <code> b </code> are of the same type, but more generally if <code> a </code> and <code> b </code> are of reference types <code> A </code> and <code> B </code>, based on classes <code> A </code> and <code> B </code> such that <code> B </code> is a descendant of <code> A </code>.
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|14 Putting a System Together]]
|
||||
[[Property:link_title|I2E: Putting a System Together]]
|
||||
[[Property:weight|-1]]
|
||||
[[Property:uuid|97460714-8ae1-a7cb-8216-235827045ea6]]
|
||||
We have now studied the constituents of Eiffel software. It remains to see how you can combine these elements into executable '''systems''' (the Eiffel concept closest to the traditional notion of program) and libraries.
|
||||
|
||||
How do you get an executable system? All you need is to <br/>
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|5 Types]]
|
||||
[[Property:link_title|I2E: Types]]
|
||||
[[Property:weight|-10]]
|
||||
[[Property:uuid|344a9fdc-3346-5e2d-5fdd-77464e92f72f]]
|
||||
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 <code> T </code> is based on a class, which defines the operations that will be applicable to instances of <code> T </code>. The difference between the two categories of type affects the semantics of an entity <code> x </code> declared of type <code> T </code>: for a reference type, the most common case, possible values for <code> x </code> are 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 <code> T </code>.
|
||||
|
||||
@@ -1,6 +1,7 @@
|
||||
[[Property:title|1 What Must I Know First?]]
|
||||
[[Property:link_title|I2E: What Must I Know First?]]
|
||||
[[Property:weight|-14]]
|
||||
[[Property:uuid|f40b4a30-87f7-2c27-b6e7-ef2f2a74661b]]
|
||||
This Invitation assumes that you have some experience of software development, but that's all. Previous exposure to object technology is not required. If you've had it, it will help; but if it has all been to notations like UML or programming languages like C++ and Java, you should not let it guide your study of this Invitation. Although Eiffel shares a number of properties with these other approaches, it takes a fresh path to object technology, based on a small number of simple, far-reaching concepts.
|
||||
|
||||
Once you are familiar with the basic ideas you may want to try them with EiffelStudio, which provides a direct implementation of the Eiffel concepts, available in a completely portable way across Windows, Linux, many versions of Unix and OpenVMS.
|
||||
|
||||
@@ -1,7 +1,7 @@
|
||||
[[Property:title|Invitation to Eiffel]]
|
||||
[[Property:weight|-15]]
|
||||
[[Property:uuid|7a606387-2653-b122-b4ef-e283a389656e]]
|
||||
The Invitation to Eiffel is a short set of pages that should give you the "essence" of what Eiffel is all about, without taking too much of your time. Enjoy this profoundly different way of thinking about developing software! When you are done, move on to the more detailed Eiffel tutorial.
|
||||
The Invitation to Eiffel is a short set of pages that should provide you with the essence the Eiffel way, without taking too much of your time. Enjoy this profoundly different way of thinking about developing software! When you are done, move on to the more detailed Eiffel tutorial.
|
||||
|
||||
|
||||
|
||||
|
||||
Reference in New Issue
Block a user