Ревнители частоты языка часто нападают на С++. Они полагают, что высшее достижение современной цивилизации — язык, построенный исключительно из атомов и скобок. По мнению этих террористов от синтаксиса, если простую переменную с первого взгляда невозможно отличить от вызова функции или макроса — это вообще не язык, а шарлатанство для развлечения праздной толпы. К сожалению, теория расходится с практикой. В реальной жизни толпа платит лишь за то, чтобы видеть языки, в которых разные идеи выглядят по-разному. «Простые и последовательные» языки никогда не пользовались особым успехом за стенками академий, а языки с блочной структурой овладели массами. Стоит ли этому удивляться? Ведь компьютерные языки приходится изучать и запоминать, а для этого используется то же серое вещество, с помощью которого мы изучаем и запоминаем естественные языки. Попробуйте-ка назвать хотя бы один естественный язык без существительных, глаголов и скобок! Я бы не рискнул. Все наши познания в лингвистике говорят о том, что эти «плохие» особенности только ускоряют изучение компьютерного языка и делают его более понятным. i++ во всех отношениях действительно понятнее, чем i:=i+1, а x=17+29 читается лучше, нежели (setq(x(+17, 29)). Речь идет не о строении компьютерного языка, а скорее о нашем собственном строении. Все уродства С++ — это в основном наши уродства. Когда вы научитесь понимать и любить его странности, когда перестанете беспокоиться о математической стройности, будет сделан ваш первый шаг к достижению элегантности в С++.

foo.Equals(bar)

foo dot Equals leftBracket bar rightBracket

- Вы меняете взгляды чаще, чем подштанники! — крикнул обозленный, прямо-таки выведенный из социостатического равновесия лорд Поппер. — Скажи мне, лорд Рассел, что осталось у тебя от дивной поры молодой? Три тома "Principia Mathematica", вымученных за долгие годы. Так вот: спешу сообщить, что Чанг Вэнь или другой какой-нибудь Пинг-Понг — не запоминаю я этих китайских имен — запрограммировал компьютер так, что все доказанное Б.Расселом в его пресловутых "Принципах" машина доказала за восемь минут со средней скоростью самоубийцы, который бросился с девяностого этажа на Юпитере, где, как известно, сила тяжести во столько же раз больше земной, сколько раз домработница господина Тичи ошиблась в счетах из прачечной в свою пользу.

Но формализованная математика не может быть записана вся полностью, и потому в конце концов приходится питать доверие к тому, что можно назвать здравым смыслом математика, — доверие, аналогичное тому, которое бухгалтер и инженер, не подозревая о существовании аксиом Пеано, питают к формуле или численной таблице и которое в конечном счете основано на том, что оно никогда не было подорвано фактами.
...
Итак, написанный по аксиоматическому методу и сохраняющий всюду в виду, как некий горизонт, возможность полной формализации, наш Трактат претендует на полную строгость — претензия, которую не опровергают ни изложенные выше соображения, ни списки опечаток, с помощью которых мы исправляли и будем исправлять ошибки, время от времени вкрадывающиеся в текст.

":=" круче, чем "="

V>

1. := гораздо понятнее, чем =
   
2. ^. гораздо понятнее, чем ->
   
3. строковые константы ограничиваются одинарными, а не двойными кавычками (в ДВА раза меньше штрихов!)
   
4. в If можно писать на одну пару скобок меньше

ПК>Ага. Еще бы лямбду добавили -- и никакие СиШарпы с Оберонами нам ни по чем

C12322 error xxx(123, 3234): unknown error in unknown lambda function.

WH>  FOR i := 0 TO Self.p DO
WH>    h.x := h.x + N[i] * Self.Pw[span - Self.p + 1].x;
WH>    h.y := h.y + N[i] * Self.Pw[span - Self.p + 1].y; //тут точка с запятой нужна
WH>    h.z := h.z + N[i] * Self.Pw[span - Self.p + 1].z  //А тут нет
WH>  END;
WH>

StatementSeq  =   Statement { ";" Statement }.

Block     =   Statement { Statement }.
...
Statement = ( xxx | yyy | zzz ) ";".

  a := 1
; b := a + 3
; c := b + a

соперников — C. Самого недостойного, т.к. в этом языке были нарушены все открытые к тому времени принципы серьезного программирования. Он запутывает студентов, допуская разный смысл для x = y и y = x и принуждая всех писать x = = y вместо обычного x = y. Только за одни эти

СГ>MODULE Test;

СГ>TYPE
СГ>  MyPrivateType = RECORD (* ... *) END; (* Другие модули этого типа не видят *)

СГ>  MyPublicType* = RECORD (* Другие модули этот тип видят *)
СГ>    PrivateVariable   : INTEGER; (* Из других модулей эта переменная не видна *)
СГ>    ReadOnlyVariable- : INTEGER; (* Другие модули могут только читать эту переменную *)
СГ>    ReadWriteVariable*: INTEGER; (* Другие модули могут и читать и писать в эту переменную *)
СГ>  END;
СГ>

TYPE
MyPrivateType = RECORD (* ... *) END; (* Другие модули этого типа не видят *)

  exportable MyPublicType = RECORD 
  PrivateVariable   : INTEGER; 
  readonly exportable ReadOnlyVariable,
  readonly            ReadOnlyLocalVariable: INTEGER; 
  exportable          ReadWriteVariable: INTEGER;
END;

Очевидно, перед нами в высшей степени устойчивый порочный круг: учителя не могут изменить свои курсы, т.к. они должны привлечь и доставить удовольствие студентам; студенты требуют то, что практикуется в промышленности; а индустрия применяет и воспроизводит то, чему обучены ее работники. Этот замкнутый круг напоминает ситуацию, описанную мной во введении к сообщению о Паскале в 1970 г.: вузы стремятся учить тому, что требует индустрия, а в индустрии практикуется то, чему ее работники выучились в вузах.

Порочный круг был однажды разорван, когда распространился Паскаль. При поддержке коллег-единомышленников и в упорном противостоянии рутинерам, Паскаль распространился в учебных заведениях и проник в индустрию. Это произошло несмотря на могучую конкуренцию со стороны индустрии и других больших организаций, в соперничестве с языками PL/1, Алгол 68 и Ада. Однако наследники Паскаля, существенно его превосходившие, Модула-2 и Оберон, не получили должного внимания среди преподавателей, и сами пали перед лицом самого недостойного из соперников — C. Самого недостойного, т.к. в этом языке были нарушены все открытые к тому времени принципы серьезного программирования. Он запутывает студентов, допуская разный смысл для x = y и y = x и принуждая всех писать x = = y вместо обычного x = y. Только за одни эти пороки он заслуживает изгнания из учреждений образования. Однако сей уродливый синтаксис был целиком воспроизведен в языке Java, принятие которого академическим сообществом произошло по меньшей мере отчасти благодаря этой преемственности.

{
  extern void XerZnaetKakayaFunkciyaFigZnaetGdeOnaOpredelena();
  XerZnaetKakayaFunkciyaFigZnaetGdeOnaOpredelena();
}

MODULE MyModule;

IMPORT L := StdLog;

BEGIN
  L.String("Привет!"); (* Компилятору сразу видно что вызывается процедура String() из модуля L := StdLog *)
END MyModule.

#define with(dest, src, type)if(type* dest = dynamic_cast<type*>(src))
void MyProc(base* p)
{
    with(x, p, T1)
        std::cout << x.Str << std::endl;
    else with(x, p, T2)
        std::cout << x.Value << std::endl;
    else 
        std::cout << "Че за хрень?" << std::endl;
}

int size=10000;
array_t<float> a(size);
array_t<float> b(size);
array_t<float> c(size);
array_t<float> d(size);
array_t<float> e(size);
array_t<float> f(size);
float x;
float y;
float z;
//тут инициализация
f*=(a/x+5)*b-(y*c-d/5)/e-z;
//что эквивалентно (без перегрузки операторов)
for(int i=0;i<size;++i)
    f.at(i)*=(a.at(i)/x+5)*b.at(i)-(y*c.at(i)-d.at(i)/5)/e.at(i)-z;

string s1;
string s2;
string s3;
string s4;
string s5;
//тут инициализация
string s6=s1+s2+s3+s4+s5;
//что эквивалентно (без перегрузки операторов)
string s6=string_cat(s1, string_cat(s2, string_cat(s3, string_cat(s4, s5))));

vector v1;
vector v2;
matrix m;
//тут инициализация
vector v3=(v1-v2)*m;
//что эквивалентно (без перегрузки операторов)
vector v2=mul_vector_matrix(sub_vector_vector(v1, v2), m);

definition Fighter;
    activity (* Syntax of the protocol, in this case it is recursive too *)
        { 
            fight       = { attack ( { defense attack } | escape | knock_out | fight ) }.
            knock_out   = KO
            escape      = RUNAWAY [ ?CHASE]
            attack      = ATTACK strike.
            defense     = DEFENSE strike.
            strike(part : Karate)   
                        = part := bodypart.
            strike(part : Karate, damage : integer)   
                        = part := bodypart damage := strength.
            bodypart : Karate
                        = LEG | NECK | HEAD.
            strength : integer
                        = integer. 
        }
        Karate   = (RUNAWAY, CHASE, KO, ATTACK, DEFENSE, LEG, NECK, HEAD);
end Fighter.

object Opponent implements Fighter;
    activity Karate implements Fighter.Karate;
    var 
        t   : object;
        hp  : integer;

    procedure knock_out;
    begin
        activity end
    end knock_out;

    procedure escape;
    begin
        if hp > 0 then 
            send Karate.CHASE 
        end;
        activity end
    end escape;

    procedure strike(part : Karate);
    begin
        hp := hp - 1
    end escape;

    procedure strike(part : Karate, damage : integer);
    begin
        hp := hp - damage
    end escape;

    begin (* Karate*)
        hp := 100;
        activity begin fight
    end Karate;
end Opponent.

object Challenger;
    import Opponent, Fighter;
    var 
        opp : Opponent; 
        f   : Fighter.Karate;
    begin
        opp := new Opponent; (* create opponent *) …
        f := new opp.Fighter.Karate; (* create dialog *)
        send Fighter.Karate.ATTACK => f; … (* fight according to the dialog protocol *)
        ... 
    
end Challenger.

init();
bool stop=false;
while(!stop && cond())
{
  bool bypass=false;
  // в первых двух строчках проверка вырождена, но я её написал для однородности кода
  if(!bypass) work1();
  if(!bypass) if(x()) { workx(); bypass=true; }
  if(!bypass) work2();
  if(!bypass) if(y()) { worky(); bypass=true; stop=true; }
  if(!bypass) work3();
  if(!bypass) if(z()) { workz(); bypass=true; }
  if(!bypass) work4();
  // условие перед итерацией
  if(!stop) next();
}

init();
bool stop=false; // для break всё равно нужно
while(!stop && cond())
{
  work1();
  if(x()) workx();
  else {
  work2();
  if(y()) { worky(); stop=true; }
  else {
  work3();
  if(z()) workz();
  else {
  work4();
  }}}
  if(!stop) next();
}

init();
LOOP 
  IF x1() THEN v1() ELSE
    w1();
    IF x2() THEN v2() ELSE 
      w2();
      IF x3() THEN v3(); EXIT ELSE (* обратите внимание на вставленные EXIT - это вместо Вашего break *)
        w3(); 
        IF x4() THEN v4() ELSE 
          w4();
          IF x5() THEN v5() ELSE 
            w5();
            IF x6() THEN v6() ELSE 
              w6();
              .................................. 
            END
          END
        END
      END
    END;
  END
  next();
END

VD>class A
VD>{
VD>    static void Test()
VD>    {
VD>        object[] array = new object[] { 1, 1.2, "Wow!", new A(), RateTime.Now };
VD>        foreach (object value in array)
VD>            Console Write("'{0]'", value);
VD>    }
VD>}
VD>

MODULE Vlad2;
IMPORT L := StdLog, D := MyDateTime;
BEGIN
  L.String("1) "); L.Int(1);
  L.String("2) "); L.Real(1.2);
  L.String("3) "); L.String("Wow!");
  L.String("4) "); L.String("Class A");
  L.String("5) "); L.String(D.NowDateTimeAsString)
END Vlad2.

MODULE Vlad2;
IMPORT StdLog;
BEGIN
  StdLog.String("0, 1, 2, 3, 4, 5, 6, 7, 8, 9");
END Vlad2.

> А опровергнуть? Т.е. реализуй Янус на Обероне, тогда можно будет уже о чём-то говорить

Ошибка #043 тип Shifting the burden of proof
Допущение истинности утвеpждения, пока не доказано обpатное. Пpимеp: "Бывают зеленые сантаклаусы, синие единоpоги, зелененькие человечки в таpелочках и пауки шиpиной в земной шаp. Докажите обpатное".

11.3 Protocol EBNF
The definition of an activity can include a formal syntax specification of a communication protocol in EBNF as a modifier to an enumeration type which defines the alphabet of terminal tokens of the syntax. The name of an activity and its enumeration type constitute the activity’s signature. Note that in EBNF protocol specifications the communication of an item from the callee to the caller is prefixed by a ‘?’.

definition Fighter;
  activity (* Syntax of the protocol, in this case it is recursive too *)
    { fight    = { attack ( { defense attack } | RUNAWAY [ ?CHASE] | KO | fight ) }.
      attack   = ATTACK strike.
      defense  = DEFENSE strike.
      strike   = bodypart [ strength ].
      bodypart = LEG | NECK | HEAD.
      strength = integer. }
      Karate   = (RUNAWAY, CHASE, KO, ATTACK, DEFENSE, LEG, NECK, HEAD);
end Fighter.

object Opponent implements Fighter;
  activity Karate implements Fighter.Karate;
    var t: object;

    procedure fight;
    begin
      while t is ATTACK do
        receive t;
        while t is DEFENSE do receive t; strike
          if t is ATTACK then strike else halt(13) end
        end;
        if t is RUNAWAY then
          if (*not exhausted*) then send Karate.CHASE end;
          return (* fight over *)
        elsif t is KO then return (* fight over *)
        elsif t is ATTACK then fight (* recursion, continue the fight *)
        else halt(13) (* protocol error *)
        end
      end
    end fight;

    procedure strike;
    begin
      if (t is LEG) or (t is NECK) or (t is HEAD) then
        receive t;
        if t is integer then (* unusual strength *) receive t end
      end
    end strike;

    begin (* Karate*)
      receive t;
      fight
    end Karate;

end Opponent.


object Challenger;
  import Opponent, Fighter;
  var opp: Opponent; f: Fighter.Karate;
  begin
    opp := new Opponent; (* create opponent *) …
    f := new opp.Fighter.Karate; (* create dialog *)
    send Fighter.Karate.ATTACK => f; … (* fight according to the dialog protocol *)
    ... 
  
end Challenger.

Наконец, как ни парадоксально это звучит, даже если бы компьютерные системы действительно были надежнее "традиционных", то это вовсе не обязательно означает, что они обеспечивают большую безопасность. Дело в том, что надежность ПО традиционно определяется степенью его соответствия зафиксированным в спецификациях требованиям; однако, часто бывает так, что ПО делает именно то, что ему и было предписано, и авария Ariane 5 – классический тому пример: и злополучное вычисление посторонней для полета величины горизонтального отклонения Инерциальной Платформы, и реакция на него вплоть до выведения из строя всех навигационных систем и бортовых компьютеров – все это случилось в полном соответствии с Требованиями, которые были частично унаследованы от Ariane 4 и не отражали новых реальностей. Более того, по сравнению с ошибками в коде именно спецификационные ошибки обычно ведут к более тяжелым последствиям – компетенции разработчиков ПО недостаточно для обнаружения таких ошибок. Программный комплекс – сложная система, однако реальный мир, отражаемый в спецификационных требованиях – еще более сложен и требует специальных экспертных знаний. Так что надежность ПО и его безопасность – понятия, хотя и перекрывающиеся, но не идентичные.

LVV>Класссс!!!!!

Безопасность пилотов и пассажиров должна начинаться уже на уровне компиляторов.

Взрыв 4 июня 1996 г. ракеты Ариан-5, стоившей пол-миллиарда долларов, имел причиной программную ошибку, которую компилятор Оберона/Компонентного Паскаля просто не пропустил бы.