«Проклятие» фигурных скобочек

Допустим, вы крупная Компания. Занимаетесь разработкой Браузера, Почтовика и даже ОС для смартфонов. Неожиданно вы понимаете, что вам не нравится современный и мощный язык С++. Ну или нравится, но работать с ним невозможно. Бывает. И вот вы, взрослая стабильная компания решаете разработать новый язык программирования. Рецепт простой. Берете бочку денег, книжки по истории ИТ, роту программистов и грузовик МакБуков. Долго думаете, быстро кодите, разводите хайп в соцсетях (реддит, фейсбук, гитхаб). И вот, в 2015-м году вы даете сообществу The Язык. Назовем его Яист.

Язык это инструмент профессионалов. Работает по профессии — значит профессионал. Что первым делом читает профессионал при изучении нового языка? Конечно, объективное мнение коллег. Оно в основном положительное. Следом за мнением коллег профессионал читает описание языка. Больше двухсот страниц. Ох. Будет, чем убить время в метро.

Быстрый старт


Hello, World!


Самый важный этап изучения.

fn main() {
  println!("Hello, world!");
}

Что мы видим? fn, фигурные скобки, точку с запятой, println!. Это макрос, как нам поясняет автор. Строковая константа это строковая константа.

Очевидно, разработчики потрудились над сокращенным написанием ключевого слова fn. Это вам не кричащее PROCEDURE, которое писать долго, еще надо Shift зажимать. Этот пункт однозначное улучшение, по сравнению с восьмидесятыми. Функция main() возвращает ничего. Пустоту. Результат void, даже указывать не надо. Попробуйте объяснить void пятиклассникам. То-то же.
Фигурные операторные скобки. Такие скобки, как известно, экономили память на машинах 70-х. Теперь они экономят время программиста. Ему некогда писать BEGIN END, ведь 21-й век за окном. Время продуктивности.

Макрос println! обращает на себя внимание восклицательным знаком. Это вам не функция. Впрочем, о происхождении макроса мы ничего не знаем, так как полные квалификаторы сущностей не нужны. Может быть, он даже встроен в язык, ведь в примере нет никакой секции импорта (на самом деле есть, любая программа импортирует ограниченный набор из библиотеки std). Нет времени выяснять, просто println! В 90-х это бы записали как Log.String(«Hello, World!»). Лихое было время, мы выживали как могли.

Не забудьте точку с запятой. Это expression based язык программирования. Точка с запятой отделит одну скобочку от другой. Завершается процедура закрывающей скобочкой. В 90-х её завершили бы END Main. Хорошо, что те времена уже прошли.

Cargo


Карго это пакетный менеджер. Скачивает зависимости, занимается их построением. Яист предполагает культ карго. В 90-е такого не было. Тут нужно отдать должное авторам. Бочка денег была выпита не зря. Языком программирования инструмента Cargo является toml — ini на стероидах.

Примеры


Дальше автор книги рассматривает пример игры в угадайки.

use std::io;
fn main() {
  println!("Guess the number!");
  println!("Please input your guess.");
  let mut guess = String::new();
  io::stdin().read_line(&mut guess)
    .ok()
    .expect("Failed to read line");
  println!("You guessed: {}", guess);
}


Мы должны обработать ввод пользователя, поэтому надо использовать библиотеку io из библиотеки std. Use std::io, Luke; И снова мы стали свидетелями того, как тщательно поработали авторы языка над синтаксисом. Раньше ведь как, IMPORT StdIO, большими буквами приходилось писать. Беспощадное отношение к рукам программиста. И два двоеточия. Возможно, это как четыре плюса в символе #. Макрос println! уже видели.

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

Наличие мутабельных и иммутабельных псевдопеременных выводит нас на новый уровень контроля над данными. Переменные больше не переменны. Будущее наступило.

String это строка. new() это new(). Потом будет io::stdin() с текущим интерфейсом и println! с возможностью автоподстановки аргументов в результирующую строку.

Развитием этого примера является генерирование рандомного числа с помощью сторонней библиотеки.

extern crate rand;


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

match guess.cmp(&secret_number) {
  Ordering::Less => println!("Too small!"),
  Ordering::Greater => println!("Too big!"),
  Ordering::Equal => println!("You win!"),
}


Метод cmp() служит для сравнения всего сравнимого. Результат сравнивается с преопределенными значениями из Enum'а c помощью оператора match. Раньше для такого был оператор CASE, условный выбор. Но теперь другие времена. Життя по-новому. Стрелочка => которую вы могли принять за составной оператор сравнения с точки зрения арабской письменности на самом деле является указателем на выражение, соответствующее варианту сопоставления.

С циклами в примере все хорошо. Есть break и continue, все как во взрослых языках. Дейкстра уже умер, можно не волноваться, что он не одобрит выход из середины цикла. Это ведь не усложняет понимание цикла. В 90-х усложняло, а сейчас люди умнее стали, и инструменты мощнее. И вообще, профессионалы не ошибаются.

Философы кушают


Структуры Philosophers Едят методом eat(). Автор плавно переходит к примеру про философов. Вводит читателя в курс дела, что есть структуры, у них есть связанные функции с параметром &self (аналог this). Это в 90-х можно было назвать связанный объект как тебе угодно, в 2015 такая фича слишком сложна для реализации. Читаем про метод new, он конструирует новый экземпляр класса. Может иметь пользовательские параметры.

Несколько философов размещаются в списке с помощью макроса vec!. Тип переменной списка мы не указываем. Но он есть.
В программу вводятся примитивы параллельного программирования.

let handles: Vec<_> = philosophers.into_iter().map(|p| {
  thread::spawn(move || {
    p.eat();
  })
}).collect();


Экономия усилий программиста во всем, в именовании методов. в синтаксисе замыканий. В отсутствии необходимости указывать тип данных. А что, и так все понятно. Это Пэ, это Век. Программирование тредов в примере опирается на мьютексы. Ну и хорошо. А то навыдумывали в 90-е всяких активных объектов. Сплошные проблемы от этого. Лучше старого доброго мьютекса ничего нет, если хочешь писать серьезный взрослый софт. Тем временем синтаксис описания импорта обрастает новыми возможностями.

use std::sync::{Mutex, Arc};


Возможности языка это краеугольный камень успеха.

Использование Яист извне


После философских обедов автор решает сфокусировать свое внимание на более приземленных вещах — на использовании Яист при построении shared library.

Это не так интересно с точки зрения программиста, ведь до сих пор функциональность shared libraries в Windows/Linux довольно убогая. Нет возможности получить информацию об интерфейсе, проблемы с кроссплатформенностью, проблемы с версионностью (точнее, отсутствие версионности, которое становится проблемой клиентского кода), авторам высокоуровневых языков приходится приземляться на уровень Cи. Некоторые языки вообще не могут так низко пасть. Но это же их проблемы. Ведь на дворе 2015-й год, а технология использования dll проверенная, надежная. У профессионалов давно есть инструменты, типа FFI. Так что не надо думать, что все технологии из семидесятых это что-то плохое. На какие укажут, те и плохие, а некоторые — хорошие. Например, модульность на уровне shared library.

#[no_mangle]
pub extern fn process() 


Это Кличка Гога Shared Library на Яисте.

Эффективный Яист



Управление памятью


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

Параметры функций


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

Тестирование


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

Условная компиляция


Еще один неожиданный гость из прошлого. Еще совсем недавно его критиковали за нарушение ожиданий от процесса компиляции. Но теперь, в 2015-м мы можем себе это позволить.

В целом, большинство перечисленных фич опирается на механизм аннотаций, который, как мне кажется, является обоюдоострым средством, которое с одной стороны позволяет управлять работой компилятора/линкера, а с другой стороны, перенос программирования в аннотации вызывает сомнения в верности выбора инструмента.

Документация


Она есть. Даже с HTML. Мы можем многое.

Итераторы


Полезная абстракция, автор описывает способы работы с ней, описывая некоторые паттерны проектирования, которые применяются в реализации итераторов Яиста. Встраивание коллекций в язык когда-то позволило вывести из под контроля сотен тысяч программистов их сотни тысяч реализаций списков и ассоциативных массивов. В 2015-м не иметь поддержки коллекций в самом языке это фу и моветон. Профессионалы не одобрят.

Многопоточность


Треды, мьютексы, каналы, безопасная передача между тредами, мутабельность/иммутабельность. Проверено-надежно.

FFI


Добро пожаловать в мир Си-интерфейсов функций и Си-типов данных. КМПВ, в мире бабочек и пони никому не придется использовать эти ужасные инструменты. А пока приходится жить в мире FFI, где дух семидесятых и свобода от порядка раскладывания параметров на стек.

Borrow and AsRef traits


Trait это объявление интерфейса метода, который используется для последующей реализации в одной или нескольких структурах. Что-то среднее между интерфейсным классом и примесью. Если вы с трудом понимаете, зачем для этого придумывать новое слово, то не огорчайтесь. Скорее всего, разработчики применяют принцип наибольшего удивления, чтобы прорваться сквозь закостенелые шаблоны в вашем мозгу.

Яист l4ngu4g3 6еЗНoГNМ



В разделе 5 описан сам язык с пояснением семантики того или иного ключевого слова. Описание довольно длинное, смешные моменты уже проявились в простых примерах. Еще среди забавных фактов можно выделить несколько:
  • все есть выражение, но мы специальным знаком можем отметить функции, которые ничего не возвращают, чувствуется глубина проработки абстрактной части
  • оператор if возвращает результат (да-да), заменяя собой тернарный оператор
  • встроенный оператор transmute, который оставляет дырку в целостности типов данных
  • яист с оператором unsafe направлен на безопасность

Владение объектами и время жизни, как фичи, возможно и простые, завязки идут на scope, затрагивая heap (из-за отсутствия сборки мусора), все это дело осложняется замыканиями, и в итоге описание концепции получается довольно сложное, и про него на Хабре напишут еще не одну статью, в попытках понять и проститьобъяснить.

В целом, синтаксис и концепции, которые за ним скрываются (или не скрываются) оставляют тягостное ощущение. Сложные примеры наполнены россыпью двоеточий, знаков восклицания, скобочками. Конечно, производители языков не очень волнуются по этому поводу. Это их дело, какой семантикой наполнять тот или иной символ.

Заключение


Конечно, данная статья это просто забавный способ передать мои ощущения от изучения свежего языка программирования. Через призму моего опыта я воспринимал то или иное решение, которое встречал в процессе изучения. Конечно, какие-то особенности я упустил. Но цель была немного не в этом.

Культурные особенности экосистемы Компании мне неизвестны, возможно, именно так должен выглядеть язык, на котором формализуют свои мысли и идеи сообщества умных людей. Но дуализм ситуации заключается в том, что Яист во многом предопределен личными особенностями создателей, которые прожили всю жизнь, с «проклятием» языков с фигурными скобочками и теперь уже тратят свои силы на поддержание экосистемы проклятия в головах людей.

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

Я увидел в языке Яист бессмысленное следование существующим внешним признакам с последовательной подменой существующих внутри парадигмы императивного программирования понятий на новые, выдуманные внутри Компании. Через несколько лет язык Яист станет частью этой реальности, и люди которые его изучат и применят на практике, поменяются сами. И начнут мыслить понятиями, которых не было еще вчера. Теми понятиями, которые для них выдумала Компания, потратив ресурсы на продукт, который удобен только определенной группе людей.

Таким вот ползучим образом человеческие сообщества продвигают свое видение мира вперед, проводят экспансию своего мировоззрения на окружающих, вознаграждают лояльных, кооптируют умных и наказывают инакомыслящих. Такой вот ход истории.

Слово «проклятие» иносказательное. Чтобы передать смысл явления. Не принимайте близко к сердцу. Мир вам.
Поделиться публикацией
AdBlock похитил этот баннер, но баннеры не зубы — отрастут

Подробнее
Реклама
Комментарии 374
  • +19
    Автор, вы в названии языка опечатались здесь:
    Использование Rust извне
    • +42
      Ещё никогда Штирлиц не был так близок к провалу.
    • –7
      Не хочется Вас огорчать и расстраивать, но в языке Яист чего-то «своего» придумали чуть более, чем нисколько.
      Если чего-то никогда не встречали, никогда не стесняйтесь поискать в интернете.
    • +2
      Далее следует объявление переменной, которое совмещено с инициализацией и размещено прямо в коде. Ну а как еще, не делать же отдельную секцию переменных, как в восьмидесятых. Тогда угрюмые колхозники писали все переменные в строго выделенном месте, чтобы потом их в этом месте найти.


      Казалось бы, при чем тут ник автора…

      Насчет фигурных скобочек и точки с запятой соглашусь, это родовая травма C, неизвестно зачем тянущаяся во все языки с тех пор.
      • –10
        Ну правда, почему в Обероне догадались, а в Rust все получилось вот так?
        • +4
          Красота в глазах смотрящего, как известно, или, другими словами, на вкус и цвет товарищей нет.
          • +1
            В «малом», возможно, товарищей нет, но в «большом» на лицо тренды, мейнстрим, антимейнстрим, групповые протестные движения. Значит, в чем-то у людей мнения совпадают. Например, про язык Rust.
          • +2
            А вам таки не нравится объявление в коде?
            Не смущает что в Rust можно написать
            let a = 5;
            let a = 6;
            и это 2 различных переменных
            Безотносительно того где это может применяться и нафига это нужно (в макросах это может быть полезно), объявления перед кодом принципиально такого не предоставят.
            • 0
              Нацеленность на safety вызывает все большее доверие.
              • 0
                Ик.
                А можно тупой-тупой вопрос?
                А как обращаться к этим двум разным переменным?
                А то я как-то по имени привык…
                • 0
                  Второй биндинг прячет первый. Т. е. после let a = 6 первого биндинга уже не увидите.
                  • 0
                    По моему эта особенность в Rust пришла прямиком из OCaml. А в OCaml она из за его repl-направленности изначальной.
            • +15
              Чем вам так неугодны скобки, и что, по-вашему мнению, лучше них? BEGIN-END? Отступы?
              • –10
                Как показывает опыт Python, отступов вполне достаточно, а точка с запятой вполне может быть необязательна (очень-очень редко действительно надо писать несколько выражений на одной строке).

                Не то что неугодны, просто можно и без них. А если без чего-то можно обойтись, то лучше так и сделать.
                • +11
                  Много, долго и счастливо живу с питоном, но иногда бывает страшно что отступишь на четыре пробела меньше и потом долго будешь искать где ты оступился
                  • +4
                    Аналогично в C-like, не напишешь фигурные скобки после if или цикла и долго ищешь, где ты оступился. Посмотрите серию статей про CppCat, в каждой третьей такие ошибки.
                    • +7
                      Это другое, со скобками достаточно приучить себя ставить их всегда после if b т.д… Невозможно приучить себя ставить правильное число пробелов или табуляций.
                      • +2
                        Простите, не согласен категорически. Какая разница, ставить скобочки или отступы?
                        • +11
                          Скобочки, они жирнее. Видны лучше на старости лет.
                          • +5
                            Тонко!
                            • +6
                              Вообще, я даже не знаю, насколько я шутил. Лично у меня глубокий импринтинг на фигурные скобочки, а в питоне терпеть не могу искать ошибки из-за табов/пробелов.
                              • +1
                                В бытность свою питонистом ни разу не натыкался на ошибки из-за отступов.
                                • +1
                                  а нельзя в редакторе символ пробела заменить на точку, как это сделано в ворде в режиме разметки?
                                  • +3
                                    А почему бы сразу в языке не заменить? Ведь пробел не видно, а точку будет видно.
                                    • –1
                                      И не на точку, а на позитивный внятный юникодный символ, скажем, “⇒”. И не умеешь настраивать клавиатуру — нет и пряничков.

                                      Пользуясь случаем, должен сказать: блистательно написано и абсолютно по делу.
                                      • +1
                                        Любые комплименты в сторону маргиналов, имеющих отношение к Oberon, на хабре караются, так что будьте осторожны, правильно выдерживайте линию партии.
                                        • –3
                                          Да мне как-то в целом на мнение здешней хипстующей школоты en mass — насрать, а вот приятному человеку сообщить, что он молодец — всегда почитал за должное.

                                          Да и вообще, я убийц языков, типа раста, повидал миллион, но побеждает всегда что-то рожденное в сарае за два часа. В КОБОЛ вон вбухали бабла сколько, а что получилось? И ведь тоже анонсировался убийца всего.

                                          Ни один более-менее серьезный си/плюс программист из числа моих знакомых не рассматривает пока раст как что-то жизнеспособное на уровне чуть выше, чем «клево, я на выходных поигрался, пора обратно за работу».
                            • 0
                              Скобки (ну то есть begin-end, я не сишник) я ставлю сразу после того, как написал if или там while. Их можно написать заранее.
                              Отступы — нельзя.

                              Поэтому я идеи с отступами боюсь. Но я не пробовал — может, оно вполне удобно и боюсь я зря.
                              • +3
                                Странная у вас какая-то идея, что отступы надо писать. Уверяю вас, никто не сидит и не расставляет вручную нужное количество пробелов, нажимая пробел 4-8-12 раз.
                                • +1
                                  Хм, а ведь вы правы. IDE ставит курсор сразу туда, куда нужно.
                                  Иногда, правда, я в самом деле вручную нажимаю пробел :). Но редко, очень редко — и обычно потому, что опять забыл, как там авто-отбивка вызывается.
                                  • +1
                                    Не только IDE, такое умеют даже текстовые редакторы типа Notepad++ или mcedit из стандартного пакета mc в линуксе.
                                  • +2
                                    У некоторых IDE (не будем показывать пальцем в лидеров индустрии) вообще странная мания ломать отступы при вставке из буфера. Со скобками в этом плане проще — код автоматом форматируется по скобкам.
                                    • –4
                                      >> Со скобками в этом плане проще

                                      Никакой разницы.
                                • 0
                                  Простите, не согласен категорически. Какая разница, ставить скобочки или отступы?

                                  Тем, что автоматический выравниватель кода понимает первое, но не понимает второе.
                                  • 0
                                    А зачем он нужен, если код уже выровнен?
                                    • +1
                                      Код — это же не статический текст в книге, который по факту «выровнен» или «не выровнен». Он меняется, иногда серьёзно. Куски кода выделяются в функции, перемещаются из функции в функцию, блоки обрамляются if-условиями, и т.п. Если в каком-нибудь C++ я могу просто поставить скобки вокруг нового скопа и запустить форматтер (который сразу учтёт новый отступ, разобьёт слишком длинные строки на части и т.п.), то в python мне приходится делать это всё руками.
                                      • 0
                                        Вините свою IDE, а не Python. Найти наибольший общий отступ выделенного куска кода и заменить его на другой — не rocket science.
                                        • 0
                                          В случае C++ я могу обойтись без умных IDE, достаточно простого редактора и clang-format.
                                          У меня, например, разработка ведётся на удалённом сервере, и код проще всего писать именно там (там все хедеры, доступы к тестовым сервисам и т.п.). IDE в таких средах не особо удобны. Мне вполне хватает emacs и различных внешних утилит.
                                          • 0
                                            Не вижу причин не деталь так же на питоне — подогнать блок табом до нужного количества отступов и какой-нибудь форматтер типа github.com/google/yapf
                                            • 0
                                              простого редактора
                                              Мне вполне хватает emacs

                                              Как раз в Emacs подобное (умный индент с поддержкой на уровне синтаксиса языка) не является особой проблемой.
                                          • 0
                                            Я не работал с IDE на Python — в pycharm, судя по описанию , есть автоформатирование.

                                            Я не вижу теоретических препятствий к тому, чтобы работало как в C++ только сначала подогнать блок табом под нужый уровень вложености. Насколько я знаю есть и реформат при вставке:

                                            Reformat on paste Use this drop-down list to specify how to place pasted code blocks. The available options are: – None — The pasted code is inserted at the caret location as plain text without any reformatting or indenting.
                                            – Indent Block — The pasted code block is positioned at the proper indentation level, according to the current Code Style Settings, but its inner structure is not changed.
                                            – Indent Each Line- Each line of the pasted code block is positioned at the proper indentation level, according to the current Code Style Settings.
                                            – Reformat Block- The pasted code block is reformatted according to the current Code Style Settings.
                                            • +1
                                              И оно (форматирование при вставке) вполне работает. Если я перед блоком поставить, например, условие на предыдущей строке, то pycharm/idea автоматически идущий следом кусок переформатировать не будет, т. к. не может угадать, к чему относится добавленное условие (к одной строке, к 5 строкам или максимально длинному участку). Поэтому есть операция surround with (ctrl+shift+j в классической раскладке), действующая на выделенный блок и обрамляющая его выбранной операцией с переформатированием кода, естественно (срабатывает ли при этом autowrap — не знаю, я им не пользуюсь).

                                              У плагина для scala есть автоперевод java->scala при вставке, что уж там.
                                              • 0
                                                Я постоянно работаю в Pycharm и могу заявить, что с помощью него я менял размер табов в кривом исходном файлике. Было у нас куча исходников, в которых блоки разделялись не по 4 пробела, а по 1. Так вот такие исходники я приводил к нормальному виду так:
                                                1. открываем этот файлик в Pycharm
                                                2. Ctrl + A
                                                3. Ctrl + X
                                                4. Ctrl + V

                                                Уровень вложенности блоков был 3-4 примерно, и все чудесно ложилось по новым правилам и интерпретировалось без ошибок. Даже править не пришлось.
                                    • 0
                                      Это лечится код стайлом, запрещающем писать как-то иначе. И со временем это вживается в подкорку мозга, и ты забываешь, что можно их и не ставить.
                                      В крайнем случае, это лечится статическим анализатором, в котором прописана выдача ошибки на написание if без скобок.
                                      • +1
                                        Ну вот уже начинается привлечение посторонних инструментов, линтеры, код-стайлы, статические анализаторы.

                                        Да, открывающую фигурную скобку со временем приучаешься писать всегда, и это хорошая практика. Ну так и отступы тоже делаешь всегда.
                                        • 0
                                          Я вообще совсем не первый год пишу на языке с фигурными скобками, но стараюсь их не ставить там, где можно этого не делать.
                                        • +5
                                          Грамматикой Rust запрещено тело условных операторов, не заключенное в блок. Проблемы нет.
                                      • +12
                                        Они стали популярны не просто так.
                                        Скобочки (особенно в сочетании с отступами) делают код гораздо более наглядным и логически разделенным.

                                        BEGIN-END плохо выполняют эту роль, потому как по написанию сливаются с самим кодом.
                                        А отступы без скобочек не так наглядны и иногда порождают проблемы, которые описаны в комментарии выше
                                        • –9
                                          Вы все хорошо говорите, убедительно, только расскажите, как вы {измеряете наглядность и логическую разделенность? В чем}? В сантиметрах или в попугаях?

                                          А BEGIN-END не сливаются с кодом, так же как не сливаются с вашим комментарием.
                                          • +8
                                            Cливается, так как использует тот же самый набор символов. К примеру:

                                            begin;
                                            int beginningBegin = 25;
                                            int endd = 34;
                                            if (beginningBegin > endd)
                                            then
                                            begin
                                            beginningBegin -= beginningBegin;
                                            endd = endd — beginningBegin;
                                            end;
                                            beginningBegin = 45;
                                            end;
                                            • 0
                                              Почему-то в примере не увидел ни одного BEGIN
                                              • +2
                                                Отступы сделайте (не первый урок по программированию ж ей богу) и ничего сливаться у вас не будет:
                                                begin;
                                                    int beginningBegin = 25;
                                                    int endd = 34;
                                                    if (beginningBegin > endd) then 
                                                    begin
                                                        beginningBegin -= beginningBegin;
                                                        endd = endd — beginningBegin;
                                                    end;
                                                    beginningBegin = 45;
                                                end;
                                                


                                                Но вообще, я предпочитаю Python-стиль, как не дублирующий скобками/BEGIN-END и так имеющуются структуру и логику. Если у вас отступы отдельно живут, а скобки отдельно и вы считаете, что скобки помогают избежать проблем, а ваш код так и остаётся с кривыми отступами, хочу вас заверить, что такой код нужно считать ущербным и нужно исправлять отступы. Итого, имея скобки как средство языка и отступы для красоты — вам приходится делать двойную работу.
                                                • 0
                                                  Соглашусь. Тоже всегда использую аргумент про двойную работу как объяснение отступов в питоне.
                                                  • 0
                                                    Уважаемые минусующие, я не запрещаю вам выполнять двойную работу и не навязываю отступы, успокойтесь и продолжайте лепить скобочки в паре с отступами.
                                                  • +1
                                                    >вам приходится делать двойную работу

                                                    В теории — да, на практике — нет. Любой адекватный редактор любого популярного языка сам проставляет отступы, если они нужны. Согласен, что по факту двойная работа выполняется, но уже не вами, а IDE.

                                                    Проблема скобок надуманна, это особенно понимаешь, если много пишешь на языке с ними и на языке без них — скорость написания кода совершенно одинаковая… по крайней мере, у меня.
                                                    • –2
                                                      Лично мне (!) проще читать (!) код без лишних знаков (а скобки при должных отступах нужны только компилятору). Я согласен, что скобки — не такая уж и глобальная проблема, при желании можно даже простой скрипт написать, который будет транслировать из синтаксиса без скобок в синтаксис со скобками, но лично я не вижу никакого преимущества в скобках, поэтому считаю их лишними.
                                                • +7
                                                  В личной удовлетворенности от работы с кодом и в желании вечерком на нём ещё пописать.

                                                  Вот со скобочками хочется, с отступами хочется (правда, не на питоне), а от бегинов и ендов вытекают глаза.

                                                  Но это субъективно всё, конечно.
                                                  • +2
                                                    Для пользователей VIM скобочки {} также удобны тем, что можно легко выполнять операции, скажем, над их содержимым
                                                    yiB — (yank inner block) скопировать внутренности {}
                                                    • +2
                                                      А ещё %, например.
                                                      • –2
                                                        Пишу в VIM уже 8 лет, на Python — 6 и вот как-то обходился d<N>d или визуальным выделением через v. Хороший Python код очень редко требует копирования больших объёмов (в том числе и из-за того, что большинство методов вмещаются в 1 экран кода), в отличие от {}-образных.
                                                        • +1
                                                          Эээ, а какая связь между количеством кода в методе и тем, используются для структурирования скобки или отступы?
                                                          • 0
                                                            В небольших методах, скажем, до 10 строк легко используется комбинация, например, d4d, которая вырезает 4 строки в буфер. Именно в этом контексте я привёл уточнение про маленькие блоки кода.
                                                            • 0
                                                              Хороший Python код очень редко требует копирования больших объёмов (в том числе и из-за того, что большинство методов вмещаются в 1 экран кода)

                                                              Вы хотите сказать, что у языков со структурированием скобками в хорошем коде методы занимают больше места, чем в Питоне?
                                                              • –3
                                                                Минимум на две строки больше, чем в питоне (это строки с открывающейся и закрывающейся скобками).

                                                                P.S. Я сам никого не минусую, но если кто-то хочет обменяться минусами — вы хоть намекните кому я задолжал.
                                                                • +1
                                                                  Во-первых, на одну (потому что открывающую скобку можно держать на одной строчке с декларацией).
                                                                  Во-вторых, когда копируется код метода, скобки включать не надо (копируется тело), поэтому все равно не понятно отличие.
                                                                  • 0
                                                                    Я изначально описывал не отличие Python от {}-языков, а то, что копирование с Python не является никакой проблемой в VIM несмотря на то, что в Python нет скобок. Более того комбинацию d<N>d можно использовать в любом коде.
                                                                    • 0
                                                                      Ага, только для d<N>d нужно знать N. Не говорите мне про relativenumber: во‐первых, мне не нравиться занимать свободное пространство когда есть более удобные способы сделать то же самое. Во‐вторых, relativenumber не поможет вам, если конца метода не видно на экране (нет, это не обязательно значит, что метод большой).

                                                                      Проще и универсальнее было бы использование привязки, которая выделяет непрерывный блок кода, в котором каждая линия имеет такой же или бо́льший отступ относительно линии, на которой стоит курсор. Это аналог iB для Python, так же хорошо работающий для других языков, если авторы не забывали ставить отступы. Из‐за автоформатирования в каждом первом редакторе кода отсутствие отступов — большая редкость.
                                                                • 0
                                                                  В случае с египетскими скобками (кажется, самый популярный сейчас стиль), то на одну больше в худшем случае, часто на ноль. На две строки больше обычно только в телах функций.

                                                                  Кроме того, вспомните PEP8. Две пустых строки до и после метода или класса на верхнем уровне, одна на любом другом (в обоих случаях — с некоторыми исключениями, на верхнем уровне редкими). А куча пустых строк для отделения логических уровней в любом языке, если метод‐таки перевалил за 10 строк (а часто и меньше), ещё сильнее уменьшают разницу. Засуньте туда ещё документацию, которая имеет относительно одинаковые размеры вне зависимости от языка (обычно могут только добавится/убраться предупреждения вида «метод выделяет память, не забудьте освободить»), и разница в размерах методов перестанет фактически зависеть от скобочек.

                                                                  На размеры методов гораздо больше влияет наличие различных выразительных средств (типа list comprehension), уровень абстракции, наличие GC.
                                                                  • 0
                                                                    Я хочу обратить ваше внимание (я и сам не заметил как отвлёкся на эту тему), что я не ставил целью сравнения Python с чем-нибудь ещё, я говорил про VIM в случае безскобочного языка на примере Python.
                                                          • +2
                                                            >> как-то обходился d-N-d
                                                            Для этого нужно ещё перепрыгнуть на первую строку.
                                                            diB работает из любого места.
                                                            Странно отрицать очевидное удобство
                                                    • +1
                                                      Как я уже говорил в этом треде, на вкус на цвет. Как по мне — так код на Python ничуть не менее нагляден и логически разделен, чем код на любом C-like.
                                                • +7
                                                  А чем вам не нравятся фигурные скобочки и точка с запятой?
                                                  Про скобки я могу только одно сказать — в текущем множестве общедоступных для ввода с любой клавиатуры символов (т.е. ASCII) их мало. Даже для шаблонов пришлось взять «угловые», которые мешаются с «больше-меньше», что не есть хорошо для компиляторов. Реально нужно не меньше 5 видов скобок.
                                                  А что касается точки с запятой — это разделитель между выражениями. Да, конечно можно попробовать исхитриться и без нее, но для меня это вполне естественный атрибут программы. Как минимум — способ визуально разделить программу на части. Это вообще малоизученная тема, точная семантика точек с запятыми и запятых «плавает» от языка к языку и даже внутри одного языка от конструкции к конструкции; но тем интереснее будет ее изучить.
                                                  • +1
                                                    Я уже написал комментом выше: habrahabr.ru/post/258391/?reply_to=8428269#comment_8428245
                                                    • +1
                                                      А зачем разделять выражения, перевод на новую строку плохо с этим справляется?

                                                      Я не говорю, что скобки вообще плохо. Просто для отделения блоков достаточно отступов. Вот если бы фигурные скобки не были заняты под блоки, их можно было бы для шаблонов использовать:)
                                                      • 0
                                                        Ну это наверное дело привычки… мне вот не нравится программирование на отступах:) (хотя я разумеется в своих программах на С++ строго придерживаюсь одного из стилей выравнивания кода — Allman_style)
                                                        Мне нравится чтобы все элементы программы были «осязаемы». С пробелами такая проблема — а сколько их нужно использовать для отступа? Один, два, четыре, что с табуляцией, в разных редакторах табуляция соответствует разному числу пробелов… Что если я ошибусь на один пробел в большой длинной программе… Пробелы невидимы, и если на них повешена какая-то семантика, то получается, что я не могу точно видеть часть своей программы, как-то так:)
                                                        Хотя возможно вы и правы, спорить не буду:)
                                                        • –3
                                                          4 пробела — стандарт де-факто. Размер табуляции в любом приличном редакторе выставляется в настройках.
                                                          • +3
                                                            А если кто-нибудь по слепоте поставит три? Как поведет себя компилятор?
                                                            • –2
                                                              Серьезно? Вы же не ставите по слепоте круглые скобки вместо фигурных.
                                                              • +4
                                                                Серьезно. Пробелы невидимы, и по слепоте три от четерых или четыре от пяти можно и не отличить:) Особенно если идет не код одного блока в столбик, а завершение сразу нескольких блоков.
                                                                • 0
                                                                  Ну вообще приличные редакторы, как я уже говорил, позволяют не заниматься такой ерундой, как ручной подсчет количества пробелов. Для увеличения и уменьшения уровня отступа есть хоткеи (обычно tab/shift+tab).

                                                                  Вы же все равно ставите отступы, хотя и используете фигурные скобки, правильно?
                                                                  • 0
                                                                    Да конечно. Я же говорю что это скорее психологический момент. В тех же Rust и Go мне например не нравится навязывание «египетского» стиля скобок как единственно возможного.
                                                                    • 0
                                                                      Безотносительно конкретного стиля скобок — насмотревшись мешанины стилей, а точнее, отсутствие хоть какого-то стиля в пределах одной страницы кода, считаю добром навязывание любого стиля как единственно возможного.
                                                                      Меньше возможностей выражения своего внутреннего мира путём (отсутствия) форматирования кода — меньше проблем, больше порядка!
                                                                • +1
                                                                  Как нефиг делать. Регулярно в XCode улетаю на 1 пробел вправо или влево, а потом туплю, почему это меня пытается поправить автоформатер.
                                                                  • +2
                                                                    Ничего не могу сказать про XCode, но в IDEA такой проблемы нет.
                                                                    • +1
                                                                      *но у меня в IDEA такой проблемы нет.
                                                                      Не обобщайте :) У кого-то и в XCode такой проблемы нет.
                                                            • +3
                                                              Мне нравится чтобы все элементы программы были «осязаемы».


                                                              Привыкните так привыкните по другому потом сравните. Вон автор статьи привык повторять название процедуры после каждого END
                                                              • +6
                                                                Мне нравится чтобы все элементы программы были «осязаемы».

                                                                Извиняюсь за башорг, но bash.im/quote/406030
                                                              • 0
                                                                Перевод строки как разделитель, мне кажется, плох тем, что придется в одну строку писать все выражения, даже если они километровые, что приводит к плохой читаемости оных. Конечно, тут можно возразить, что само по себе наличие таких выражений — тревожный звоночек, однако все же бывают исключения.
                                                                • +4
                                                                  Есть такие вещи, как знаки переноса, в человеческой речи они тоже есть. В Python для этого в конце строки достаточно поставить \ или воспользоваться услугами круглых скобок. Примеры:

                                                                  a = MyComplexClass("one", "two three four five...")\
                                                                      .do_something()
                                                                  
                                                                  a = (MyComplexClass("one", "two three four five...")
                                                                          .do_something()
                                                                  )
                                                                  
                                                                  something_really_long_long_long_long = ComplexSomethingLikeJavaPeopleLike(
                                                                      1, 2, 3
                                                                  )
                                                                  
                                                          • +5
                                                            А вы все о том же:) Эх не хакер вы, не хакер…
                                                            • –1
                                                              В предыдущем посте уже овер 400 комментов, значит тема актуальность не теряет.
                                                              • 0
                                                                Хоть я и не согласен с автором, но такие темы здорово мотивируют на разработку и доведение до ума собственных идей и проектов в области создания языков программирования, за что автору спасибо.
                                                            • +5
                                                              Многие могут не сразу понять, но в обычной жизни, вне рамок критических статей надо всеми силами топить за Rust. Просто потому, что он станет врагом С++. Это как в квартире, зараженной клопами, надо завести тараканов, как естественных врагов.
                                                              • +5
                                                                Вас C++ огорчает что ли?
                                                                • –4
                                                                  Все в машину, это же дитфуд!Нет.
                                                                  image
                                                                • 0
                                                                  У него уже есть серьезный недостаток — практически неверифицируемый компилятор: он при чистой сборке качает бинарный stage0 rustc, т. к. компилятор раста написан на расте. А до раннего rustc, написанного на ocaml'е больше 4к промежуточных сборок.

                                                                  В общем, для ответственных применений практически невозможно убедиться в том, что в код компилятора не добавляются отсутствующие в исходниках закладки при сборке. Если оно и взлетит, то до появления альтернативного компилятора в некоторых областях оно неприменимо, как и java. Только кресты, только хардкор.
                                                                  • 0
                                                                    Компилятор Си делает то же самое, в чём проблема?
                                                                    • +2
                                                                      Компиляторов C чуть больше одного. Соответственно используя два разных компилятора C (clang/gcc/tcc/whatever) можно провести кроссвалидацию: что stage1 собранный, например, gcc и tcc приводят к одинаковым stage3, а значит, что в валидируемом компиляторе скрытых (не присутствующих в исходниках) закладок нет.

                                                                      Если в случае раста писать компилятор на подмножестве языка, для которого будет иной компилятор, то такая кроссвалидация тоже будет возможна. Но это явно не актуальные вещи при разговоре о версии 1.0.

                                                                      Лично мне интересно, насколько rust будет удобен для bare-metal targets. Из интересного нашёл проект zinc.rs
                                                                      • +1
                                                                        Понятно.

                                                                        Да, на это время надо. Для Си тоже не сразу много компиляторов появилось. В целом, увидеть альтернативную реализацию было бы круто — известно, что компилятор у Раста внутри местами очень страшный, да и какие-то глобально нерешённые вопросы есть.

                                                                        А про bare-metal — регулярно вижу в IRC и на Reddit людей, программирующих микроконтроллеры на Расте. zinc.rs-то это больше фреймворк, а в принципе libcore — это используемая без аллокатора часть стандартной библиотеки. Достаточно немаленькая часть, для голого железа подходящая. Если интересно, могу попробовать конкретные статьи найти.
                                                                        • +1
                                                                          В zinc очень понравился макрос ioreg! для описания регистров, оно тогда выглядит куда гуманнее, чем привычные сишные портянки define'ов.
                                                                        • +1
                                                                          # gcc и tcc приводят к одинаковым stage3
                                                                          Т.е. никогда, *.h и ABI — разные.
                                                                          • –3
                                                                            Почему у gcc stage1, собранного gcc, и gcc stage1, собранного tcc, будет разный ABI (на выходе компиляции тем и другим)? Они ж из одних и тех же исходников gcc собираются?
                                                                            • –1
                                                                              Странные мимокрокодилы прошлись минусами, но так и не осилили ответить, почему две сборки binutils+gcc (собранные из одних и тех же исходников с одинаковыми параметрами, но разными компиляторами) должны при компиляции и линковке одного и того же исходника с одинаковыми параметрами должны давать разный результат (в том числе, использовать разный ABI)? При условии отсутствия скрытых закладок, конечно.
                                                                              • +3
                                                                                <internet-white-knighting>
                                                                                Я думаю, они просто не поняли из объяснений, что сравнивается в при diverse double-compiling.

                                                                                Пусть C(s) = b обозначает применение компилятора C к исходнику s с получением бинарной программы b.

                                                                                Теперь, у нас есть компилятор gcc версии 2 в бинарном виде (gcc2); есть исходники gcc версии 3 (gcc3); и есть другой компилятор, tcc версии 1, в бинарном виде (tcc1).

                                                                                Теперь мы два раза компилируем gcc3:
                                                                                gcc2(gcc3) = gcc3-gcc
                                                                                tcc1(gcc3) = gcc3-tcc

                                                                                Эти две программы очевидно могут быть различными, иметь разный ABI, и так далее. Но суть в том, что у них должно быть идентичное поведение. Если в gcc2 есть закладка, то поведение gcc3-gcc и gcc3-tcc должно отличаться.

                                                                                Поэтому делают ещё один проход, собирая одну и ту же программу под одну и ту же архитектуру, используя (предполагаемо) один и тот же алгоритм:
                                                                                gcc3-gcc(gcc3) = gcc3-gcc x 2
                                                                                gcc3-tcc(gcc3) = gcc3-tcc x 2

                                                                                Вот теперь полученные программы должны совпадать побитово (при соблюдении ряда условий на сам компилятор gcc, типа независимости выдачи от фаз Луны). Если они не совпадают, то здесь определённо что-то нечисто.
                                                                                </internet-white-knighting>

                                                                                У Rust нет альтернативного бинарного компилятора для бутстрепа. Так что для подобной верификации остаётся только мучительный путь — компилировать исходники вручную, получив чистую копию, лишённую закладок.
                                                                                • 0
                                                                                  (с) К.О.

                                                                                  … У Rust нет альтернативного бинарного компилятора для бутстрепа

                                                                                  Я ответил, что у gcc — тоже нет альтернативы… clang — может быти использован для бутстрапа, но мы же закладки ищем?! или только возможность получить бинарные копии? В инкладах операционных систем отрабатывается какой компилятор сейчас их компилирует и эта информация протягивается по стайджам, можно подшаманить между ними, но мы же доказывает отсутствие закладок?!

                                                                                  tcc уже не в состоянии скомпилировать gcc, a так бы было интересно, 32 битный ABI 2000х на 64 битной платформе, мог бы быть условием не включать закладки, доказательство отсутсвия срабатывания, которое мы бы получили в этом эксперименте — только для очистки совести.

                                                                                  Ни один компилятор не несет описание всех сред на которых он может быть развернут, ему скармливают описания этой среды, разное ABI, у меня на компе два 32 и 64(в разных каталогах, можно поставить еще + делать кроссплатформенные среды), которое будет скормлено — зависит от начального компилятора и ключей при начале построения., по этому…

                                                                                  … Но суть в том, что у них должно быть идентичное поведение.
                                                                                  — сильно сильное требование, недоступное даже с ключем -O0, но нам нужен же -O2 (как минимум?) Суть разного ABI — РАЗНОЕ поведение, (как пример: codingadventures.me/2015/03/13/c-tail-recursion-using-64-bit-variables не всегда умеет разварачивать хвостовую рекурсию).

                                                                                  … Поэтому делают ещё один проход, собирая одну и ту же программу под одну и ту же архитектуру, используя (предполагаемо) один и тот же алгоритм
                                                                                  — еще раз огорчу (упростим, даже одним компилятором) на старте имея разный ABI: одну и ту же программу не получим (разные ветви #if#else), (архитектуру?) мы выбрали разную, ((предполагаемо) один и тот же алгоритм) гарантированно разные алгоритмы (различие в количесве бит, регистров, разные оптимизации )

                                                                                  Но, таки, да, если одним и тем же компилятором компилировать одну и туже программу на той же архитектуре, (предполагаемо) получим одни и те же объектные файлы. (если компилятор не подмешивает случайные данные, для секурности, или версионности)
                                                                                  • +1
                                                                                    В инкладах операционных систем отрабатывается какой компилятор сейчас их компилирует и эта информация протягивается по стайджам, можно подшаманить между ними, но мы же доказывает отсутствие закладок?!
                                                                                    Закладок в компиляторе. Содержимое инклюдов — это проблемы операционной системы. Точно так же закладка в драйвере файловой системы — это не проблема компилятора и не покрывается DDC-тестом.

                                                                                    Суть разного ABI — РАЗНОЕ поведение
                                                                                    Важно наблюдаемое поведение.

                                                                                    (архитектуру?) мы выбрали разную
                                                                                    Для DDC-теста должны выбирать одинаковую. Иначе конечно же результаты двойной компиляции будут отличаться, лол.
                                                                                    • –2
                                                                                      ))) Вы, просто, бальзам моего сердца, такое чувство от родственной души! Ваш, К.О.

                                                                                      Великолепно!
                                                                                      "… Закладок в компиляторе..." — проведя неполное тестирование, на «специально настроенной среде», мы можем утвеждать их отсутствие! Встраивайся сколько хочешь. Главное — не менять собираемый образ компилятора.
                                                                                      "… Важно наблюдаемое поведение...", на специально настроенной среде — просто не достижимо в современных «троянцах»!
                                                                  • +3
                                                                    Из серии новейших яистов мне более всего как язык симпатичен dlang.
                                                                    • +25
                                                                      Это херня какая-то, а не статья.

                                                                      Конечно, данный комент это просто забавный способ передать мои ощущения от прочтения статьи. Через призму моего опыта я воспринимал то или иное предложение, которое встречал в процессе прочтения. Конечно, какие-то особенности я упустил. Но цель была немного не в этом.
                                                                    • +4
                                                                      Просто из праздного интереса, а каков был путь автора в изучении и использовании языков? Например, я начинал с PHP (тогда только вышла версия 4) / JS, потом lua и Си, потом С++. Это из того, на чём были большие проекты, мелочь не считается.
                                                                      • +3
                                                                        Pascal изучал в школе.
                                                                        Работал на freepascal, oberon (модификация), на последней работе java, js, ибо прижал кризис :)
                                                                        Вне работы go, dart, вот, на раст смотрю внимательно.
                                                                        Еще на actionScript что-то делал, не помню уже.
                                                                        • +13
                                                                          А. Собственно, все понятно — вы на си и крестах не писали.
                                                                          • –6
                                                                            Что понятно? Не писал на Си — не мужик?
                                                                            • +17
                                                                              Это не я сказал. Но оценивать откровенно низкоуровневый язык не имея с опыта работы с подобными — верный путь к фэйлу. Да и оценивать язык по синтаксису — паршивая идея.
                                                                              • –5
                                                                                На Обероне операционные системы пишут, я разбирал их исходники. Достаточно низкоуровнево? Или надо ниже? Или надо строго на Си писать, чтобы пройти Ваш фейсконтроль?

                                                                                А синтаксис отличная штука для первичной оценки, первые этапы боли я получу, выписывая кренделя с исходником. А вы говорите — паршивая идея. Как же поступить? Кто же прав?
                                                                                • +10
                                                                                  М. И что? Вон МС на C# ОС писали. Или Mirage, в котором OCaml-а 90%. Низкоуровневыми это их не делает.

                                                                                  А правы, скорей всего, авторы Rust-a, которые делают хороший, годный язык для людей, которые годами писали на C/C++.
                                                                                  • –4
                                                                                    А на Обероне на ОС написана на сто процентов. Почему-то Вирта не смутила недостаточная низкоуровневость. Может, это лично Вы без Сишечки не можете, но обобщать не стоит.
                                                                                  • –3
                                                                                    Минусуют, очевидно, люди, совершенно не разбирающиеся в истории ИТ, и скорее всего, есть какая-то сложность в понимании того, что есть синтаксис. Процитирую: «Синтаксические единицы являются одновременно и основными смысловыми понятиями любого языка: модуль, класс, блок, функция, процедура, метод, оператор, выражение. Ну а что, если не система понятий и их количество, может характеризовать сложность языка.»
                                                                                    • –4
                                                                                      Борьба мировоззрений. Скобочки победили. На данный момент.
                                                                                      • +4
                                                                                        Семантическии скобочки ничем не отличаются от begin и end. Это исключительно представление границ блока.
                                                                                        • –1
                                                                                          Мировоззрение отличается. Скобочки это всего лишь проявление. В статье описано.
                                                                                    • +3
                                                                                      Вы про одноименную систему, предназначенную для исполнения программ на нём (написанную Виртом)?

                                                                                      По-моему, если для языка нужна своя ОС — это фигня какая-то, простите.
                                                                                      • –3
                                                                                        По-моему, если для языка нужна своя ОС — это фигня какая-то, простите.

                                                                                        Речь шла о том, что на Обероне можно писать ОС. И все остальное тоже можно. Если вы из этого делаете вывод, процитированный выше, то вам надо всерьез задуматься о возможной дислексии.
                                                                                        • +2
                                                                                          Ну я попытался понять, о каких ОС на Обероне идёт речь, и нашёл в Википедии следующее:

                                                                                          В 1989 году в Швейцарской высшей технической школе Цюриха (ETH) была выпущена первая реализация Оберона для процессоров семейства NS32000. Он был создан в качестве компонента операционной среды Оберон.


                                                                                          Из вас же ничего, кроме оскорблений, не вытянешь.

                                                                                          Если вы из этого делаете вывод, процитированный выше, то вам надо всерьез задуматься о возможной дислексии.


                                                                                          Если вы по одной фразе диагностируете у собеседника болезнь, то вам надо всерьёз задуматься о чём-то похуже.
                                                                                          • –2
                                                                                            Вы как-то плохо искали. А какой поисковый запрос вы использовали?
                                                                                            я тут погуглил



                                                                                            Рекомендую Вам обратить внимание на ссылку www.projectoberon.com
                                                                                            • –1
                                                                                              Ответа я не дождусь, наверное.
                                                                                            • –2
                                                                                              Вы попытались что-то понять, назвав то, что я сказал, фигней? RLY?
                                                                                          • +1
                                                                                            Мне кажется, Вы уже совсем непростительные вольности себе позволяете со словами оппонента.

                                                                                            Поясните пожалуйста, если не трудно, логическую цепочку по переходу от тезиса
                                                                                            На Обероне операционные системы пишут
                                                                                            к тезису
                                                                                            если для языка нужна своя ОС — это фигня какая-то
                                                                                            а господа плюсанувшие ваш комментарий могут присоединиться к формулированию логической цепочки.
                                                                                        • +1
                                                                                          Или вот, на Обероне микроконтроллеры для БПЛА программируют, я сам покупал девборду и программировал. Достаточно низкоуровнево? Или надо ниже? Компилировал Оберон в двоичный (и троичный) код. Ниже?
                                                                                          • +6
                                                                                            Вообще, мне не хочется вас расстраивать, но Оберон никому особо не нужен и забыт. На данный момент, мне кажется, вполне заслуженно. У нас уже есть куча отличных языков высокого уровня на любой вкус, под любую задачу и любую платформу.
                                                                                            • +1
                                                                                              Ну, мы помним, значит не забыт. А вы и дальше стреляйте себе в ноги, вас же не расстраиваетесь от такого, ведь в жизни низкоуровневого программиста главное challenge. И высокий порог вхождения, чтобы конкурентов поменьше.
                                                                                              • +6
                                                                                                Считаю себя высокоуровневым программистом, челлендж — да, главное, но я лучше в темплейты и что-нибудь такое подолблюсь, если говорить о челлендже в языке. Пишу на C++, да.

                                                                                                Что я делаю не так? :)

                                                                                                Хотя не пятница ещё сегдня для таких тредов :)
                                                                                            • +1
                                                                                              … И каждый день появляются все более новые и более отличные языки-однодневки…
                                                                                              • +5
                                                                                                Стоп. Вы сказали, что для оценки низкоуровневых языков надо поработать на низком уровне. Вам говорят, что опыт такой работы есть. А вы начинаете переобуваться на ходу и подменять тезисы (вместо «поработай низкоуровнево» теперь «Оберон забыт»). Нехорошо так делать. В приличных обществах за такое канделябром, знаете ли.
                                                                                                • +2
                                                                                                  Не, не поймите неправильно, я подумывал продолжить про низкоуровневость и семантику. Но потом вспомнил, что не разговариваю с фанатиками, сказал, что хотел и ушел заниматься делом.
                                                                                                  • +1
                                                                                                    То есть вы только несете чушь, а отвечать за нее не привыкли.
                                                                                                    • 0
                                                                                                      В данном случае от этого не будет ни удовольствия, ни толка.
                                                                                                      Я лучше пойду упаковку HLS timed metadata для erlyvideo дописывать.
                                                                                                      • 0
                                                                                                        Срезал
                                                                                                        За столом разговор пошел дружнее, стали уж вроде и забывать про Глеба
                                                                                                        Капустина… И тут он попер на кандидата.
                                                                                                        — В какой области выявляете себя? — спросил он.
                                                                                                        — Где работаю, что ли? — не понял кандидат.
                                                                                                        — Да.
                                                                                                        — На филфаке.
                                                                                                        — Философия?
                                                                                                        — Не совсем… Ну, можно и так сказать.
                                                                                                        — Необходимая вещь. — Глебу нужно было, чтоб была — философия. Он
                                                                                                        оживился. — Ну, и как насчет первичности?
                                                                                                        — Какой первичности? — опять не понял кандидат. И внимательно
                                                                                                        посмотрел на Глеба, И все посмотрели на Глеба.
                                                                                                        — Первичности духа и материи. — Глеб бросил перчатку. Глеб как бы
                                                                                                        стал в небрежную позу и ждал, когда перчатку поднимут.
                                                                                                        Кандидат поднял перчатку.
                                                                                                        — Как всегда, — сказал он с улыбкой. — Материя первична…
                                                                                                        — А дух?
                                                                                                        — А дух — потом. А что?
                                                                                                        — Это входит в минимум? — Глеб тоже улыбался. — Вы извините, мы
                                                                                                        тут… далеко от общественных центров, поговорить хочется, но не особенно-то
                                                                                                        разбежишься — не с кем. Как сейчас философия определяет понятие
                                                                                                        невесомости?
                                                                                                        — Как всегда определяла. Почему — сейчас?
                                                                                                        — Но явление-то открыто недавно. — Глеб улыбнулся прямо в глаза
                                                                                                        кандидату. — Поэтому я и спрашиваю. Натурфилософия, допустим, определит это
                                                                                                        так, стратегическая философия — совершенно иначе…
                                                                                                        — Да нет такой философии — стратегической! — заволновался кандидат.
                                                                                                        — Вы о чем вообще-то?
                                                                                                        — Да, но есть диалектика природы, — спокойно, при общем внимании
                                                                                                        продолжал Глеб. — А природу определяет философия. В качестве одного из
                                                                                                        элементов природы недавно обнаружена невесомость. Поэтому я и спрашиваю:
                                                                                                        растерянности не наблюдается среди философов?
                                                                                                        Кандидат искренне засмеялся. Но засмеялся один...

                                                                                    • +2
                                                                                      Так, в своём понимании мира я не разуверился, теперь опишу, ради чего оно было.

                                                                                      Каждый инструмент должен быть на своём месте. Например, lua хорош декларативным стилем и гибкостью в структуре кода. Очень круто для небольших скриптов в играх, описании GUI, гибких конфигураций. К тому же сегменту можно отнести js.

                                                                                      Си — необходимое зло, которое живёт даже там, где ничего другого нет. Но вот C++ — швейцарский армейский нож на низком уровне бытия. Он не всегда есть там, где есть си, зато позволяет сделать приемлемый API для работы. C++ может быть и ужасен, и прекрасен, зависит от продуманности каждой отдельной библиотеки.

                                                                                      Есть и третья сторона, когда скрипты нужны вчера, увидит их никто, но должно работать. В таких условиях применяется perl, python, tcl и подобное.

                                                                                      Есть ещё и специфические отрасли, требующие какой-то специальный язык…

                                                                                      Rust я отношу ко второй категории, кандидат на апгрейд швейцарского армейского ножа. Пока только кандидат. Заменит он в моём арсенале С++ или нет — можно будет решать после хотя бы 50к строк рабочего кода. А в остальном — не стоит рассматривать микробов в молоток.
                                                                                      • 0
                                                                                        lua удобен для использования с большим ядром, написанным на «ужасном» С++. Вы же не заставите гейм-дизайнера изучать С++, к тому же модульность языка никакая, дизайнер всё вам там порушит. И перекомпиляция безумная совершенно. Для языков типа Оберона lua теряет свои качества, так как на Обероне можно и ядро написать, и модульно скриптики пописать.
                                                                                        • +2
                                                                                          А так же теряется существенная кодовая база сообщества C/C++, что в низкоуровневой разработке игр вызывает неслабые тормоза в развитии проекта. Плавали, знаем. Если приделать к молотку лупу, всё равно на микроскоп похоже мало.
                                                                                          • –5
                                                                                            Речь идёт про особенности языка программирования как формального аппарата. Бесспорно, тоннаж готовых к использованию вычислений штука хорошая, но вторичная.