Дол­гие годы я был фанатом раз­работ­ки под Windows, о чем немало писал в этот вот луч­ший компь­ютер­ный жур­нал всех вре­мен и народов. Со вре­менем я перешел под Mac OS и UNIX. Работая под макосью, я оза­дачил­ся выбором тул­зы для соз­дания плат­формо­неза­вис­мых прог­рамм. Что же пред­почесть? Java? Mono? Слиш­ком скуч­но. Я выб­рал… Eiffel. И вот почему.
 

Eiffel

Все началось тог­да, ког­да на гла­за мне попалась пуб­ликация про­фес­сора питер­ско­го уни­вер­ситета ИТМО Бер­тра­на Мей­ера, по сов­мести­тель­ству авто­ра и соз­дателя язы­ка Eiffel. Язык этот выз­вал у меня непод­дель­ный инте­рес.

Бер­тран Мей­ер счи­тает­ся одним из ведущих спе­циалис­тов по объ­ектным тех­нологи­ям, более того, он сто­ял у их исто­ков и написал на эту тему мно­жес­тво книг. Но глав­ная его зас­луга зак­люча­ется в соз­дании ОО‑язы­ка с фичей кон­трактно­го прог­рамми­рова­ния — Eiffel, который он раз­работал в далеком 1985 году. Этот язык обла­дает механиз­мом управле­ния памятью (сбор­кой мусора), мно­жес­твен­ным нас­ледова­нием, обоб­щенным прог­рамми­рова­нием, ста­тичес­кой типиза­цией, аген­тами (механиз­мами замыка­ния и лям­бда‑выраже­ниями).

В том же году Бер­тран орга­низо­вал ком­панию ISE (Interactive Software Engineering), которая ста­ла занимать­ся раз­вити­ем и под­дер­жкой язы­ка, поз­же (1993 год) ком­пания была пере­име­нова­на в Eiffel Software. Ком­пания вхо­дит в спи­сок 500 самых успешных незави­симых биз­нес‑ком­паний в мире. При этом надо учи­тывать, что она занима­ется толь­ко раз­вити­ем и про­дажей язы­ка и инс­тру­мен­тов прог­рамми­рова­ния на нем. Отсю­да сле­дует, что популяр­ность это­го язы­ка доволь­но низ­кая. Ведь самые извес­тные язы­ки прог­рамми­рова­ния — это откры­тые и/или сво­бод­ные тех­нологии: Python — open source про­дукт; C/C++ с момен­та сво­его рож­дения широко извес­тны, бла­года­ря мегаком­пании, где были соз­даны, — AT&T (Bell Labs), которая рас­простра­няла их бес­плат­но (так как на тот момент не име­ла пра­ва про­давать софт); Pascal, Lua — резуль­таты иссле­дова­ний уни­вер­ситет­ских групп и потому сво­бод­ные... С дру­гой сто­роны, ком­мерчес­кие язы­ки из‑за сво­ей зак­рытос­ти мало рас­простра­нены, исклю­чени­ем слу­жит раз­ве что Objective-C, который был лицен­зирован сна­чала NeXT, затем, по нас­ледс­тву, Apple.

Eiffel исполь­зует­ся в серь­езных раз­работ­ках, от которых зависят жиз­ни людей: в аэро­кос­мичес­кой отрасли, в бан­ков­ско‑финан­совой сфе­ре… Кли­ента­ми Eiffel Sofware явля­ются Boeing, Rosenberg и EMC.

В ори­гиналь­ной реали­зации язы­ка (от Eiffel Software, которую мы будем рас­смат­ривать в даль­нейшем в статье) код, про­ходя про­межу­точ­ный уро­вень, пре­обра­зует­ся в текст на язы­ке C и толь­ко потом ком­пилятор пос­ледне­го соз­дает дво­ичный код исполня­емой прог­раммы; имен­но такой под­ход и поз­волил добить­ся плат­формо­неза­виси­мос­ти язы­ка. Меж­ду тем сущес­тву­ют реали­зации, генери­рующие дво­ичный код непос­редс­твен­но из язы­ка Eiffel. Нап­ример, этим занима­ется open source про­ект Visual Eiffel, одна­ко он прек­ратил свое раз­витие еще в 2007 году. Кро­ме язы­ка, прог­раммис­ту пос­тавля­ется мощ­ная интегри­рован­ная сре­да раз­работ­ки — EiffelStudio. Эта сис­тема вклю­чает интегри­рован­ные инс­тру­мен­ты для работы с кодом, при­сущие сов­ремен­ным сре­дам прог­рамми­рова­ния, биб­лиоте­ки на все слу­чаи жиз­ни и дру­гое. Оче­вид­но, что Бер­тран, сле­дуя за сво­им стар­шим кол­легой — Ник­лаусом Вир­том, при­менил в сво­ем язы­ке вырази­тель­ность, при­сущую язы­кам пос­ледне­го: Pascal, Ada, Oberon. И это прек­расно! Одна­ко самая глав­ная вкус­ность язы­ка зак­люча­ется в воз­можнос­ти кон­трактно­го прог­рамми­рова­ния. Усто­ялось мне­ние, что прог­рам­мный про­дукт не может быть сво­боден от багов, если, конеч­но, это не «Hello, World».

Меж­ду тем раз­работ­чики Eiffel утвер­жда­ют, что соз­данное с помощью их средств ПО может быть таким. Для под­твержде­ния они при­водят механизм кон­трактно­го прог­рамми­рова­ния. Его осно­ва (что ясно из наз­вания) — вза­имо­дей­ствие по кон­трак­ту, подоб­ное биз­нес‑отно­шени­ям. Так, кли­ент (client), зап­росив что‑то у исполни­теля (supplier), обя­зует­ся выпол­нить пре­дус­ловия, тог­да как исполни­тель дол­жен осу­щес­твить пос­тусло­вия. Нап­ример, кли­ент дол­жен быть уве­рен, что таб­лица не пус­тая и клю­чевое поле не пус­тое, тог­да он может обно­вить таб­лицу, вста­вив эле­мент, ассо­цииро­ван­ный с дан­ным клю­чом. С дру­гой сто­роны, исполни­тель дол­жен записать получен­ный эле­мент, ассо­цииро­ван­ный с передан­ным клю­чом, в таб­лицу, так­же в том слу­чае, если она пол­ностью запол­нена, он ничего не дол­жен делать. Получа­ется двой­ная про­вер­ка. Это поз­воля­ет удоб­ным обра­зом докумен­тировать исходни­ки, для чего в EiffelStudio пре­дус­мотре­ны спе­циаль­ные средс­тва. Пре­дус­ловия или пос­тусло­вия могут содер­жать­ся в одном клас­се, который для это­го и соз­дан. Это так называ­емые инва­риан­ты. Инва­риант может содер­жать одно или более усло­вий. Они полез­ны при рег­ресси­онном тес­тирова­нии и управле­нии кон­фигура­цией. Таким обра­зом, кон­трактное прог­рамми­рова­ние пред­став­ляет собой сле­дующую реали­зацию (надс­трой­ку) над при­выч­ным ООП: объ­екты име­ют более тес­ные свя­зи в прог­рам­мной сре­де.

Из это­го раз­говора вытека­ет сле­дующая фича EiffelStudio под наз­вани­ем AutoTest. Все зна­комы с тех­никой раз­работ­ки прог­рам­мно­го обес­печения через тес­тирова­ние, вве­ден­ной Кен­том Беком в 1999 году, при­меняя которую прог­раммист перед написа­нием рабоче­го кода прог­раммы дол­жен написать тест для это­го кода. Все это хорошо и про­ходи­ло на ура. Но с раз­вити­ем тех­нологий под­ходы дол­жны улуч­шать­ся. В свя­зи с необ­ходимостью соз­дания более слож­ного прог­рам­мно­го обес­печения прог­раммис­ту надо боль­ше кон­цен­три­ровать­ся на цен­траль­ной задаче раз­рабаты­ваемо­го при­ложе­ния, а не кода, тес­тиру­юще­го его. Механизм AutoTest выпол­няет за прог­раммис­та про­цеду­ру соз­дания тес­тов, таким обра­зом, он авто­мати­чес­ки про­водит рег­ресси­онное тес­тирова­ние, избавляя прог­раммис­та от лиш­них забот.

Ну­левые ука­зате­ли — бич раз­работ­ки объ­ектно ори­енти­рован­ного прог­рам­мно­го обес­печения. Исполь­зуя язык Eiffel, раз­работ­чик может не бес­поко­ить­ся о них. То есть если car равен nullptr, то сле­дующий код не при­ведет к кра­ху при­ложе­ния (и кон­цу све­та) car->drive();. Ком­пилятор Эйфе­ля гаран­тиру­ет, что car не будет равен nullptr ни при каких обсто­ятель­ствах. Поэто­му разыме­нова­ние про­исхо­дит без проб­лем, а ком­пилятор выдаст пре­дуп­режде­ние о том, что про­изош­ло малень­кое недора­зуме­ние. Такая воз­можность язы­ка называ­ется Void Safety.

Ка­кое бы количес­тво новых и раз­нооб­разных поточ­ных фрей­мвор­ков и биб­лиотек ни выходи­ло для таких про­цедур­ных язы­ков, как C/C++, C# или Java, проб­лема парал­лель­ных вычис­лений оста­ется острой, спо­соб­ной оста­вить раз­работ­чика без сна в глу­бокой отладке. Сов­ремен­ность и будущее тре­буют парал­лель­ной обра­бот­ки, но она содер­жит гон­ки, дид- и лай­фло­ки, труд­ности в отладке и дру­гие пре­лес­ти. Но и в этом слу­чае Eiffel может упростить нам жизнь! Бла­года­ря рас­ширению язы­ка — SCOOP (Simple Concurrent Object-Oriented Programming) Eiffel поз­воля­ет раз­рабаты­вать устой­чивые, не под­вержен­ные кон­курен­тным ситу­ациям мно­гопо­точ­ные при­ложе­ния.

Та­ким обра­зом, EiffelStudio поз­воля­ет вес­ти «бес­шовную» раз­работ­ку. Это зна­чит, что для про­екти­рова­ния (в том чис­ле соз­дания UML-диаг­рамм), пос­тро­ения поль­зователь­ско­го интерфей­са, собс­твен­но написа­ния Eiffel-кода, ведения докумен­тации, тес­тирова­ния и раз­верты­вания готово­го при­ложе­ния исполь­зует­ся одна сре­да раз­работ­ки, которая содер­жит все перечис­ленные инс­тру­мен­ты, поз­воляя раз­работ­чику не поль­зовать­ся внеш­ними средс­тва­ми.

 

Сила в библиотеках

Что­бы уви­деть мощь Eiffel, взгля­нем на стан­дар­тные биб­лиоте­ки язы­ка. В общей слож­ности их 12 штук, в боль­шинс­тве сво­ем они незави­симы от плат­формы, хотя и есть исклю­чения. Самая важ­ная биб­лиоте­ка — базовая EiffelBase, она содер­жит базовые струк­туры и алго­рит­мы. Короче говоря, эта либа вклю­чает в себя клас­сы, сос­тавля­ющие ядро Eiffel-сис­темы: они слу­жат для ариф­метичес­ких опе­раций и обра­бот­ки исклю­чений. EiffelVision 2 — кросс‑плат­формен­ная гра­фичес­кая биб­лиоте­ка, поз­воля­ющая стро­ить рас­ширен­ный поль­зователь­ский интерфейс для при­ложе­ний, работа­ющих в любой мало‑маль­ски рас­простра­нен­ной опе­раци­онной сис­теме: Windows, UNIX, Linux, VMS и дру­гих. Сле­дующие две либы плат­формо­зави­симые — работа­ют толь­ко в Windows. WEL (Windows Eiffel Library) осно­выва­ется на Win32 API (отсю­да зависи­мость) и поз­воля­ет стро­ить при­ложе­ния, исполь­зуя средс­тва пос­ледней: окна, диало­ги, эле­мен­ты управле­ния, при­сущие Win-при­ложе­ниям, а так­же мно­гое дру­гое. EiffelCOM упро­щает раз­работ­ку при­ложе­ний, исполь­зующих ком­понен­тную модель Microsoft (что понят­но из наз­вания либы). Кли­ент‑сер­верная биб­лиоте­ка EiffelNet поз­воля­ет обме­нивать­ся струк­турами дан­ных меж­ду компь­юте­рами по сети. EiffelTime реали­зует раз­носто­рон­нюю работу с датой и вре­менем. При вклю­чении биб­лиоте­ки EiffelStore в при­ложе­ние оно получа­ет воз­можность работы с дан­ными раз­личных баз дан­ных через драй­вер ODBC, сре­ди них: Oracle, SQL, Ingres, Sysbase. EiffelThread реали­зует в при­ложе­нии под­дер­жку мно­гопо­точ­ности, при этом оно оста­ется незави­симым от аппа­рат­ного и прог­рам­мно­го окру­жения и в рав­ной сте­пени под­держи­вает­ся во всех Windows NT, UNIX сис­темах на про­цес­сорах x86/64, SGI рабочих стан­циях и супер­компь­юте­рах Cray. Eiffel2Java соз­дает интерфейс меж­ду прог­раммой, написан­ной на Eiffel, и Java-при­ложе­нием, таким обра­зом, из пер­вой мож­но выз­вать вто­рую. С помощью EiffelWeb мож­но на язы­ке Eiffel раз­рабаты­вать динами­чес­кие HTML-стра­ницы, содер­жащие фор­мы, обра­баты­ваемые CGI-скрип­тами. Биб­лиоте­ки EiffelLex и EiffelParse исполь­зуют­ся для соз­дания тек­сто­вых и син­такси­чес­ких ана­лиза­торов. Они могут быть при­мене­ны для раз­работ­ки тран­сля­торов самых раз­ных видов, в том чис­ле ком­пилято­ров и интер­пре­тато­ров.

И это толь­ко те биб­лиоте­ки, которые вхо­дят в стан­дар­тную пос­тавку Эйфе­ля! Мож­но попол­нить этот набор, купив необ­ходимую либу у Eiffel Software, или попытать счастья, поис­кав в сооб­щес­тве Open Source.

 

Инсталляция EiffelStudio

EiffelStudio — ори­гиналь­ная сре­да прог­рамми­рова­ния на язы­ке Eiffel. Для ее уста­нов­ки пред­лага­ются два вари­анта: вер­сия EiffelStudio — Enterprise Evolution Edition и вер­сия под лицен­зией GPL. Средс­тва раз­работ­ки я пред­почитаю ста­вить под сво­бод­ной лицен­зией, потому что испы­татель­ного сро­ка мне хва­тит вряд ли. При таком рас­кла­де удоб­нее уста­новить EiffelStudio из тер­минала. Но сна­чала...

Пе­ред уста­нов­кой EiffelStudio надо уста­новить Xcode — сом­нева­юсь, что его у тебя нет, а вот тул­зы коман­дной стро­ки для него могут отсутс­тво­вать. В таком слу­чае перей­ди на сайт Apple в раз­дел Downloads for Apple Developers (что­бы зай­ти туда, понадо­бит­ся активный Apple ID), затем, про­ведя неболь­шой рисеч, ска­чай отту­да Command Line Tools (OS X 10.9) for Xcode, пос­ледняя вер­сия тулз на момент написа­ния статьи была Late December 2014.

Веб-страница скачивания тулз командной строки
Веб‑стра­ница ска­чива­ния тулз коман­дной стро­ки

В резуль­тате на жес­ткий диск тво­его мака будет слит пакет — образ дис­ка для уста­нов­ки ути­лит коман­дной стро­ки. Уста­нов­ка стан­дар­тная и не пред­став­ляет труд­ностей. Обра­ти вни­мание, пос­ле уста­нов­ки тулз надо хотя бы раз запус­тить Xcode, что­бы при­нять усло­вия лицен­зии; если это­го не сде­лать, в будущем по «непонят­ной» при­чине может не работать ком­пиляция кода из EiffelStudio.

Пос­ле это­го необ­ходимо уста­новить юник­совую окон­ную под­систе­му X11. В нас­тоящее вре­мя она не вхо­дит в стан­дар­тную пос­тавку опе­раци­онной сис­темы, одна­ко име­ется в пакете XQuartz, раз­рабаты­ваемом Apple. Забегая впе­ред: этот пакет нужен для про­рисов­ки окон­ного интерфей­са Eiffel IDE, вмес­те с ним уста­нав­лива­ется тер­минал XTerm, который пред­почти­тель­но исполь­зовать во вре­мя уста­нов­ки язы­ка и сту­дии. Ска­чай XQuartz с сай­та. Он пред­став­ляет собой обыч­ный пакет для уста­нов­ки. Пос­ледняя на момент сда­чи статьи вер­сия — 2.7.7.
Вдо­бавок надо уста­новить MacPorts, пред­став­ляющий собой репози­торий UNIX-при­ложе­ний для OS X. Сре­ди них мы най­дем EiffelStudio. Что­бы уста­новить MacPorts, надо ска­чать содер­жащий его пакет по сле­дующей ссыл­ке. Я пред­полагаю, что у тебя пос­ледняя на дан­ный момент вер­сия яблочно‑дес­ктоп­ной опе­раци­онной сис­темы. Содер­жимое пакета «вывали­вает­ся» стан­дар­тным обра­зом.

На­конец под­готови­тель­ные эта­пы выпол­нены, и мы прис­тупа­ем к уста­нов­ке язы­ка и сис­темы Eiffel. Открой пред­варитель­но уста­нов­ленный XTerm и вве­ди в него: sudo port install eiffelstudio. Запус­тится про­цесс уста­нов­ки, будут ска­чаны все необ­ходимые биб­лиоте­ки и раз­решены зависи­мос­ти. Все это тянет­ся доволь­но дол­го, поэто­му ты вся­ко успе­ешь «отки­нуть­ся на спин­ку крес­ла», а то и заварить чай­ку.

Ког­да про­цесс будет завер­шен, надо про­извести некото­рые нас­трой­ки, без них ничего работать не будет. Корот­ко говоря, если в XTerm ты исполь­зуешь bash (по умол­чанию так и есть), надо внес­ти изме­нения в его про­филь. Для это­го, оста­ваясь в XTerm, открой про­филь для редак­тирова­ния, вве­дя и выпол­нив: cat >> ~/.bash_profile. Затем в откры­тый файл надо вбить четыре сле­дующие стро­ки:

export ISE_PLATFORM=macosx-x86-64
export ISE_EIFFEL=/Applications/MacPorts/Eiffel_13.11
export GOBO=$ISE_EIFFEL/library/gobo/svn
export PATH=$PATH:$ISE_EIFFEL/studio/spec/$ISE_PLATFORM/bin:$GOBO/../spec/$ISE_PLATFORM/bin

Те­перь, перей­дя на пос­леду­ющую стро­ку, нажати­ем завер­ши ввод. Что­бы изме­нения всту­пили в силу, надо перезаг­рузить про­филь bash, для это­го выпол­ни: source ~/.bash_profile.

Ус­танов­ка и кон­фигури­рова­ние завер­шены, поз­драв­ляю! Теперь мож­но запус­тить EiffelStudio, для это­го в коман­дной стро­ке вве­ди estudio. Если пред­варитель­ные шаги выпол­нены вер­но, пошур­шав вин­честе­ром, твой мак запус­тит сту­дию! Обра­ти вни­мание, если запус­тить сту­дию под рутом, она не будет фун­кци­они­ровать. Запус­кать надо из‑под обыч­ного поль­зовате­ля.

 

Копаемся в EiffelStudio

Как я уже ска­зал, EiffelStudio пред­став­ляет собой самодос­таточ­ную сре­ду раз­работ­ки. В одной статье мы не смо­жем рас­смот­реть всю встро­енную сис­тему инс­тру­мен­тов, одна­ко часть из них мы пощупать обя­заны.
Пос­ле пре­дыду­щего шага сту­дия уже откры­та. Сра­зу пос­ле запус­ка появ­ляет­ся окно соз­дания или выбора про­екта.

Окно создания/выбора проекта
Ок­но соз­дания/выбора про­екта

В вер­хней час­ти окна отоб­ража­ются две заготов­ки для про­екта, в зависи­мос­ти от опе­раци­онной сис­темы и уста­нов­ленных фрей­мвор­ков их чис­ло может отли­чать­ся. Пер­вая — Basic application (no graphics library included) — это заготов­ка для кон­соль­ного при­ложе­ния, вто­рая — Graphics application, multi platform, with EiffelVision 2 — соз­дает окон­ный интерфейс, исполь­зуя ука­зан­ную биб­лиоте­ку.

По тра­диции соз­дадим при­ложе­ние пер­вого типа, выб­рав в этом спис­ке соот­ветс­тву­ющий пункт и нажав акти­визи­ровав­шуюся кноп­ку Create.

От­кро­ется диалог задания име­ни про­екта, его кор­невого клас­са и рас­положе­ния. Так как во вре­мя соз­дания каж­дого про­екта EiffelStudio дол­жна ском­пилиро­вать заголо­воч­ные фай­лы, убе­дись, что отме­чен фла­жок Compile Project, далее жми OK. Появит­ся воп­рос, который пред­лага­ет под­твер­дить ком­пиляцию заголов­ков.

Подтвердить компиляцию заголовков?
Под­твер­дить ком­пиляцию заголов­ков?

Сог­лаша­емся, жмем OK, EiffelStudio запус­тит про­цеду­ру тран­сля­ции. Взгля­нем на исходник Eiffel-прог­раммы (в панели Groups спра­ва выбери пункт APPLICATION). Как и ожи­далось, для кон­соль­ного при­ложе­ния он невелик:

note
description : "consoleproject1 application root class"
date : "$Date$"
revision : "$Revision$"
class
APPLICATION
inherit
ARGUMENTS
create
make
feature {NONE} -- Initialization
make
-- Run application.
do
--| Add your code here
print ("Hello Eiffel World!%N")
end
end

Но выг­лядит стран­но. Рас­смот­рим основные момен­ты. Пос­ле клю­чево­го сло­ва note сле­дуют ком­мента­рии — опи­сание про­екта, и, соот­ветс­твен­но, этот текст про­пус­кает­ся ком­пилято­ром. С клю­чево­го сло­ва class начина­ется опи­сание клас­са. Пос­коль­ку Eiffel под­держи­вает мно­жес­твен­ное нас­ледова­ние, в бло­ке inherit может содер­жать­ся нес­коль­ко родитель­ских клас­сов. В области create опи­сыва­ются конс­трук­торы клас­са, их может быть нес­коль­ко, впро­чем, это неуди­витель­но. Пос­ле клю­чево­го сло­ва feature находят­ся опи­сания свой­ств и методов. Сле­дующее за ним сло­во в фигур­ных скоб­ках (в дан­ном слу­чае NONE) опре­деля­ет видимость свой­ств и методов клас­са по отно­шению к дру­гим час­тям прог­раммы.

Так, сло­во NONE экви­вален­тно private из C++, то есть озна­чает зак­рытые чле­ны. Так­же на этом мес­те могут находить­ся сло­ва: ANY — экви­валент public (откры­тые чле­ны) и CHILD — protected (дос­туп толь­ко для детей клас­са, вклю­чая его самого). Эти же клю­чевые сло­ва могут исполь­зовать­ся при осу­щест­вле­нии нас­ледова­ния клас­сов (модифи­като­ры дос­тупа для клю­чево­го сло­ва inherit). В при­мере выше в области feature находит­ся опи­сание про­цеду­ры make (конс­трук­тора). Тело про­цеду­ры начина­ется с клю­чево­го сло­ва do, а закан­чива­ется по тра­диции пас­каля сло­вом end. Как вид­но, точ­ка с запятой в Eiffel не тре­бует­ся, одна­ко этот сим­вол не зап­реща­ется. Внут­ри про­цеду­ры вызыва­ется фун­кция print, которая тра­дици­онно выводит в кон­соль передан­ный в парамет­ре текст. Однос­троч­ные ком­мента­рии здесь начина­ются с сим­вола двой­ного тире (--).

Пос­ле обзо­ра кода самое вре­мя его запус­тить на выпол­нение, для это­го финали­зируй про­ект, выб­рав в меню Project пункт Finalize. Пос­ледова­тель­но запус­тятся шесть эта­пов ком­пиляции и финали­зация, которая пред­полага­ет непос­редс­твен­ный перевод C-кода в машин­ные коман­ды. Текущий про­ект выпол­нится незамет­но, а в кон­соли отоб­разит­ся текст «Hello Eiffel World!».

Результат нескольких запусков программы
Ре­зуль­тат нес­коль­ких запус­ков прог­раммы

Пос­ле финали­зации про­екта в пап­ке с ним обра­зует­ся исполня­емый файл с рас­ширени­ем *.e.

 

Файлы

Не отхо­дя от кас­сы, на осно­ве текуще­го про­екта пос­мотрим на работу с фай­лами. Спер­ва в под­катало­ге с про­ектом (там, где файл application.e) соз­дай тек­сто­вый файл input.rtf (OS Х не любит txt) с любым содер­жимым. В коде в начале бло­ка feature объ­яви две перемен­ные:

input_file: PLAIN_TEXT_FILE
output_file: PLAIN_TEXT_FILE

Об­рати вни­мание: объ­явле­ние перемен­ных по син­такси­су близ­ко к пас­калю, исклю­чение сос­тавля­ет отсутс­твие клю­чево­го сло­ва var. Тип PLAIN_TEXT_FILE пред­став­ляет собой фай­лы, содер­жащие пос­ледова­тель­нос­ти ASCII-сим­волов. Далее в начале конс­трук­тора надо соз­дать эти два фай­ла — один для вво­да, дру­гой для вывода:

create input_file.make_open_read ("input.rtf")
create output_file.make_open_write ("output.rtf")

За­тем в цик­ле про­исхо­дит чте­ние и запись каж­дого сим­вола. Eiffel име­ет две фор­мы цик­ла: базовую и ите­раци­онную. Вто­рая исполь­зует­ся в слу­чае обра­бот­ки эле­мен­тов кол­лекции (мас­сивов, спис­ков и так далее). Пер­вая — во всех осталь­ных слу­чаях. Син­таксис записи цик­лов в Eiffel отли­чает­ся от всех дру­гих язы­ков, в нашем слу­чае цикл будет иметь такой вид:

from
input_file.read_character
until
input_file.exhausted
loop
output_file.put (input_file.last_character)
input_file.read_character
end

Клю­чевое сло­во from зна­мену­ет блок ини­циали­зации. Пос­ле выпол­нения метода read_character свой­ство last_character объ­екта input_file будет содер­жать про­читан­ный сим­вол. Блок until содер­жит усло­вие прек­ращения выпол­нения цик­ла. В нашем слу­чае, пока свой­ство exhausted объ­екта, пред­став­ляюще­го чита­емый файл, не ста­нет истинным (то есть пока файл не закон­чится), будет выпол­нять­ся тело, сле­дующее за мет­кой loop. Здесь про­исхо­дит запись счи­тан­ного ранее сим­вола в файл вывода и чте­ние сле­дующе­го сим­вола из фай­ла вво­да. В кон­це прог­раммы методом close надо зак­рыть оба фай­ла:

input_file.close
output_file.close

Прог­рамма готова, про­тес­тируй. Если все вер­но, то в пап­ке с исполня­емым фай­лом появит­ся тек­сто­вый файл вывода, содер­жащий текст, вве­ден­ный в файл вво­да.

 

Оконный интерфейс

Под занавес взгля­нем на вто­рую заготов­ку при­ложе­ния в EiffelStudio — Graphic application, multi-platform, with EiffelVision 2. В момент соз­дания, про­ходя по шагам визар­да, ука­зыва­ем имя и рас­положе­ние будуще­го про­екта, отме­чаем минималь­ный набор визу­аль­ных эле­мен­тов: глав­ное меню, панель инс­тру­мен­тов и про­чее.

EiffelStudio Application Wizard
EiffelStudio Application Wizard

Пос­ле соз­дания про­екта, если его финали­зиро­вать и запус­тить, отоб­разит­ся при­ложе­ние с окон­ным интерфей­сом.

Оконное приложение
Окон­ное при­ложе­ние

Ос­новным клас­сом при­ложе­ний, исполь­зующих биб­лиоте­ку EiffelVision, явля­ется EV_APPLICATION. Кро­ме того что этот класс ини­циали­зиру­ет окон­ную под­систе­му, исполь­зуемую на плат­форме, под которую ты ком­пилиру­ешь про­ект (по умол­чанию в боль­шинс­тве опе­раци­онных сис­тем исполь­зует­ся GTK), вдо­бавок этот класс орга­низу­ет глав­ный цикл для обра­бот­ки сис­темных событий. Для сво­ей работы EV_APPLICATION исполь­зует фун­кци­ональ­ность дру­гих клас­сов, к при­меру EV_TIMEOUT пери­оди­чес­ки (через опре­делен­ный интервал) с помощью аген­тов вызыва­ет события; с дру­гой сто­роны, объ­ект клас­са EV_COLOR занима­ется зак­раской вид­жетов и эле­мен­тов. Глав­ное окно пред­став­ляет­ся объ­ектом first_window клас­са MAIN_WINDOW.

Сна­чала в конс­трук­торе make_and_launch вызыва­ется метод default_create, который под­готав­лива­ется EV_APPLICATION, затем в про­цеду­ре prepare соз­дает­ся и отоб­ража­ется окно (объ­ект клас­са MAIN_WINDOW), наконец, методом launch при­ложе­ние запус­кает­ся на выпол­нение, в резуль­тате чего мы видим окно прог­раммы.

 

Заключение

Eiffel содер­жит огромное количес­тво син­такси­чес­ких отли­чий от стан­дар­тных (C-подоб­ных) язы­ков: объ­явле­ние клас­сов, перемен­ных, методов, мас­сивов; условные, цик­личес­кие конс­трук­ции; пре­дус­ловия, пос­тусло­вия, клас­совые инва­риан­ты; вза­имоот­ношения кли­ента и пос­тавщи­ка и мно­гие дру­гие язы­ковые конс­трук­ции содер­жатся в Эйфе­ле. В совокуп­ности все они приз­ваны улуч­шить качес­тво раз­рабаты­ваемо­го прог­рам­мно­го обес­печения, сде­лав его более безопас­ным и надеж­ным. Эти шаги пред­при­няты раз­работ­чиками язы­ка для того, что­бы сде­лать работу прик­ладных прог­раммис­тов более про­дук­тивной.

Хо­тя статья подош­ла к кон­цу, нам не уда­лось рас­смот­реть все фичи язы­ка Eiffel. Оно и понят­но, автор язы­ка пос­вяща­ет его опи­санию тома объ­емом в тысячу стра­ниц! Язык мощ­ный, слож­ный и при этом инте­рес­ный. Он пред­став­ляет собой новый взгляд на раз­работ­ку прог­рам­мно­го обес­печения, новый инс­тру­мен­тарий, све­жий под­ход.

Боль­шую помощь в изу­чении язы­ка, конеч­но же, ока­зыва­ют при­меры. Eiffel не стал в этом пла­не исклю­чени­ем, в пап­ке Eiffel_Examples находит­ся огромная под­борка самых раз­ных при­меров: от кон­соль­ного каль­кулято­ра до окон­ного веб‑бра­узе­ра.

Eiffel непос­редс­твен­но пов­лиял на мно­жес­тво сов­ремен­ных язы­ков, сре­ди которых Delphi, C#, Ruby и дру­гие. И хотя этот язык испы­тал на себе вли­яние пас­каля, алго­ла, меж­ду тем он име­ет такие конс­трук­ции, которые не встре­чают­ся в дру­гих язы­ках прог­рамми­рова­ния.

Как утвер­жда­ет Бер­тран Мей­ер, «C не тот язык, на котором прог­раммист дол­жен писать при­ложе­ния, вли­яющие на челове­чес­кие жиз­ни, по край­ней мере C дол­жен выпол­нять лишь про­межу­точ­ную роль, которая соз­дает­ся более безопас­ным и естес­твен­ным язы­ком».

Оставить мнение