Microsoft: Rust является 'лучшим шансом' в отрасли программирования безопасных систем

Автор оригинала: Joab Jackson
  • Перевод

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


YouTube: Ryan Levick - Rust at Microsoft

Независимо от того, сколько вложений компании-разработчики могут потратить на инструментарий и обучение своих разработчиков, «C++, по своей сути, не является безопасным языком», сказал Райан Левик (Ryan Levick) 'cloud developer advocate' из Microsoft на виртуальной конференции AllThingsOpen в прошлом месяце, объясняя в виртуальной беседе почему Microsoft постепенно переходит с C/C++ на Rust для создания своего инфраструктурного программного обеспечения. И вдохновляет других гигантов индустрии программного обеспечения задуматься о том же.



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


Фактически, Microsoft сочла C++ менее приемлемым или менее подходящим для написания критически важных программ. Отрасль крайне нуждается в переходе на производительный язык, безопасный в плане работы с памятью для низкоуровневой разработки систем. А лучший выбор на рынке сегодня — это Rust, сказал Левик.


C/C++ не могут быть исправлены


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


Но отрасль страдает от всех ошибок, связанных с памятью многие из которых представляют угрозу безопасности. Сейчас по словам Левика, 70% CVE созданных в Microsoft, являются проблемами безопасности памяти. «Нет никакой реальной тенденции, это соотношение не растёт и не убывает, оно просто остается неизменным», — сказал он. «Несмотря на огромные усилия с нашей стороны, чтобы решить эту проблему, это все еще кажется обычным делом».


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


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


Один из подходов, который давно используется, состоит в том, чтобы больше обучать программистов написанию более безопасного кода. Но «нет никаких доказательств того, что комплексное обучение разработчиков на C и C++ действительно решит эту проблему любым существенным способом», — сказал Левик, сославшись на собственные наработки в Microsoft, предназначенные для внутреннего обучения разработчиков.


Статический анализ упоминается, как еще одно возможное решение. Но статический анализ требует слишком много времени: его необходимо подключить к системе сборки. «Так что есть большой стимул не использовать статический анализ» — сказал Левик. «Если он не включен по умолчанию, он не поможет».


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


Лучший шанс для отрасли


В ответ на проблему ошибок связанных с использованием памяти Центр реагирования Microsoft Security запустил инициативу «Microsoft's Safe Systems Programming Languages Effort | BDL198» (видео-интерью с Левиком, где он подтверждает свои утверждения изложенные в данной статье). В ней некоторая работа была посвящена укреплению C/C++. Язык Verona — новый язык программирования, создаваемый для безопасного низкоуровневого программирования, также был создан здесь. Но третий аспект стратегии этого проекта, в которую они верят больше всего, заключается в том, чтобы поддержать «наилучшие шансы отрасли для непосредственного решения этой проблемы».


«И мы считаем, что это Rust», — сказал он.


По производительности Rust находится на одном уровне с C/C++ и, возможно, даже немного быстрее. Rust повышает производительность труда разработчиков благодаря менеджеру управления пакетами, современным средам тестирования и тому подобному. И программисты за это любят Rust.


Но главная причина, по которой Microsoft так увлечена Rust, заключается в том, что это язык безопасный для памяти, с минимальными проверками во время выполнения. Rust выделяется в создании корректных программ. Корректность означает примерно то, что программа проверяется компилятором на небезопасные операции, что приводит к меньшему количеству ошибок во время выполнения. Ключевое слово 'unsafe' является опцией, но не используется по умолчанию. Небезопасный код в Rust почти всегда является подмножеством большего объема безопасного кода. Небезопасный 'unsafe' режим необходим для задач по выделению памяти, например для написания драйверов устройств. Но даже здесь небезопасные части заключены в безопасный API.


По словам Левика, эту способность безопасно программировать не следует воспринимать легкомысленно. Фактически, Rust может обеспечить более чем 10-кратное улучшение, что делает его полезным для инвестиций. Во многом это связано с тем, что практически весь код C/C++ нуждается в аудите на предмет небезопасного поведения, в то время как небезопасный код написанный на Rust, который необходимо будет проверить, является лишь небольшим подмножеством основной кодовой базы.


Хотя Microsoft оптимистично настроена на Rust, Левик признает, что разработчики ядра Microsoft не прекратят использовать C/C++ в ближайшее время.


«У нас в Microsoft много C++ и этот код никуда не денется» — сказал он. «Фактически, Microsoft продолжает писать на С++ и будет писать некоторое время».


Много инструментария построено на C/C ++. В частности, двоичные файлы Microsoft сейчас почти полностью собраны компилятором Microsoft Visual C++, который собирает двоичные файлы MSVC, тогда как Rust использует LLVM.


Возможно, самая большая проблема, тем не менее, является культурной. «Есть некоторые люди, которые хотят выполнить свою работу на языке, который они уже знают», — признался Левик.


Тем не менее, индустрия, похоже, движется в сторону Rust. Amazon Web Services использует его, в частности для развертывания безсерверной среды выполнения (Lambda serverless runtime), а также для некоторых частей EC2. Facebook начал использовать Rust как и Apple, Google, Dropbox и Cloudflare.


Объявлены даты All Things Open 2020: 20-22 октября.


Ресурс "The New Stack" не позволяет оставлять комментарии непосредственно на сайте. Мы приглашаем всех читателей, которые хотят обсудить историю или оставить комментарий, посетить нас в Twitter или Facebook. Мы также приветствуем ваши новостные советы и отзывы по электронной почте: **feedback@thenewstack.io.


Amazon Web Services является спонсором The New Stack.


2020 The New Stack. All rights reserved.

10 июня 2020 10:10 автор Joab Jackson
AdBlock похитил этот баннер, но баннеры не зубы — отрастут

Подробнее
Реклама

Комментарии 592

    +7

    Радоваться или бояться? А то Майкрософт, помнится, любила java и Интернет...

      +12

      А с джавой или интернетом разве что-то случилось?

        +33

        С джавой случился C#. И, кажется, это даже неплохо.

          +19
          Более того, несмотря на то, что случился C# и это очень хорошо, с джавой тоже все очень даже неплохо.
          В этом смысле даже котлин воспринимается, как позитивная тенденция мира джавы.
            +18

            Именно благодаря C# с джавой всё хорошо. Всё дело в том, что Java очень неповоротлива в плане добавления нового функционала, а C# её расшевелил. Конкуренция всегда идёт на пользу обеим сторонам.

              +1
              Так, а при чём здесь? Вы про джаву или JVM? Я не сведущ в джаве, но судя по релиз ноутам последних версий, язык, как-то не очень в последнее время развивается, сравнивая с шарпом. (Может я что-то пропустил). А вот Котлин прекрасен, здесь нечего добавить.
                +1
                Вы что-то пропустили. В последнее время (после появления нового релизного цикла) java развивается очень быстро. Застой был до java 9.
                  +2

                  Так этот цикл и ускорение выпусков и пришло в Java благодаря наличию конкуренции в лице C#.

                    +3
                    Наверное, не только C#, но и Kotlin.
                    +2
                    Значит пропустил. Ну, это отлично. Здоровая конкуренция еще никому не вредила.
                      0
                      Если бессмысленное напихивание несвязных уродливых фичей называть развитием, то да…
                        +2
                        Если records, sealed classes, project loom, начала паттерн матчинга — это бессмысленное напихивание несвязных уродливых фичей, то да…
                          0

                          В общем-то именно, что да, потому что они как бы сверху приделываются бантиком, поэтому они получаются слишком частными и хрупкими.
                          Вот например records. Пришлось аж целое новое ключевое слово вводить, в то время как в Rust это просто частный случай обычной структуры, на которую просто добавили некоторые дополнительные derive'ы.

                            0
                            Да, я именно это и имею в виду, спасибо.
                            Sealed классы без smart cast-ов будут выглядеть уродско. Новый instanceOf тут не замена, имхо, получается ужасный код.
                            Лямбды имеют уродский синтаксис, да ещё и _ запрещено. И похерили проверяемые исключения.
                            switch-expression сделали «чтобы был», добавив отдельный кусок синтаксиса для него.
                              +3

                              Видимо языки мейнстримные нужно как и президентов, иногда менять

                                0

                                > Менять
                                > Как президентов


                                Да ну, бред какой-то.


                                </sarcasm>

                            0
                            Читаю комментарий и не знаю, о шарпы Вы или о джаве)

                            Я не вижу проблемы в большом количестве сахара и не вижу большой проблемы в том, что код может стать короче. Разумеется, что иногда это ведёт к удару по производительности, но никто не заставляет использовать сахар. На том же шарпе, условно, можно писать как на си даже без вызовов (практически) к ГК. Главное, чтобы вы понимали, как этот сахар работает.
                            Более того. Если вы мего-зануда и не хотите чтобы кто-то использовал в вашем коде определённые вещи — уделите полчаса и напишите анализатор (имеется в виду выбросить ошибку или ворнинг).

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

                              0
                              Для любителей есть C++/CLI.
                                0
                                Верно. Не скажу, что это выглядит супер… но, порой приходилось юзать.
                        0
                        Java в последнее время начала догонять Котлин по сахару, насколько это возможно, разумеется
                          –4
                          и близко не стоит. Котлин продуманный язык, в отличие от.
                    +3
                    С Java случились несовместимые расширения в Microsoft JVM. Потом суд, развод и никакой любви.
                    С Интернетом случился Internet Explorer.
                      +1
                      Кто сказал, что здесь история не повторится? NIH-синдром

                      P.S.Кроме MS JVM еще был J#.
                        0
                        Кто сказал, что здесь история не повторится?
                        Подвижки уже есть.
                          0
                          «Чукча — писатель, чукча не читатель». Ссылка «тухлая» — December 2, 2019
                          И проект «Verona» о котором вы нам по секрету поведали, то о нем Левик говорит в своем видео, которое указано. И там он говорит, что не знает статуса и планов этого эксперимента. Но Verona лежит на гитхаб-е — да.
                            +1
                            Ссылка «тухлая» — December 2, 2019
                            Так это всего полгода назад.
                            0
                            Они по-другому никогда и не делали. Всё своё.
                        –3

                        С java случился эпичный батл в суде, после чего Sun запретило MS делать свою JVM (которая отличалась от задаваемых Sun стандартов)… собственно тогда Sun вообще задалась вопросом более жёсткого контроля выпускаемых JVM. Впрочем я бы сказал что в данном случае это успех, а вот если бы Sun потупило ещё пару лет, то проблем в Java было бы столько же, сколько было в вебе с ie6 в эпоху chrome-ff-ie8. А так поимело проблем ограниченное количество java-девелоперов + некоторая часть кода внезапно превратилась в тыкву.

                        –1

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


                        Жалко наивных людей, которые «хотят быть как Microsoft» и ведутся на этот промоушен, а потом остаются без реального опыта в востребованных технологиях.

                          –2
                          Это вы про C#? Вот там уж точно всё, как вы описали: язык придуман в Microsoft, реализаций не то одна, не то полторы, на других платформах всё грустно…

                          Срочно все забываем C#!
                            –3

                            C# был официально выпущен Microsoft в комплекте со средствами разработки и фреймворками. Что выпущено ими по Rust? Предлагаете считать заявление какого-то подметайла официальной позицией Microsoft? Тогда что за язык Verona? Я запутался: что мне выбирать для проекта следующего космического корабля: Rust или Verona?

                              –2

                              Наверное пишете с компьютера под Singularity? Когда собираетесь переходить с IronRuby на Rust?

                          +20
                          Rust — прекрасный язык, но ИМХО проблема Микрософт далеко не в безопасности языка. Безопасный язык не поможет против удаления файлов пользователя, бесконечного цикла перезагрузок при включенном fast boot. Он бессилен против бесконечных усилий отделов по перестановке кнопочек и добавлений «крутейших новых эмодзи». Если сокращения тестов и тестировщиков продолжатся, если не будет как-то переделана политика одобрения новых релизов — язык, даже самый крутой, не поможет.
                            +14

                            Но зато это прекрасно поможет самому расту еще больше утвирдиться а мире

                              +11
                              А при чем тут это, если весь пост, по сути, о безопасной работе с памятью в rust и C/C++? Проблема МС тут именно в безопасности языка и их статистика CVE соответствует показателям других, у кого много C/C++ кода. Инструмент стал помехой и пришло время его сменить.
                                –2
                                их статистика CVE соответствует показателям других
                                А где можно посмотреть это статистику «других»?
                                А то обсасывается одна цифра из одного источника, как я вижу.
                            • НЛО прилетело и опубликовало эту надпись здесь
                                +1
                                Теоретически — часть тестов можно убрать потому, что язык всё-таки безопасный и не допускает некоторых видов ошибок.
                                Однако, как Вы верно заметили — ошибок «удаление файлов пользователя» и «бесконечного цикла перезагрузок» ни один язык программирования (по кр.мере, из известных мне) устранить не может.
                                  +3

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

                                    –1

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

                                      +1

                                      Я говорил не о расте.

                                      +2
                                      в которых можно доказать отсутствие такого поведения


                                      Погодите-погодите! Вы не приведете пример, как доказать отсутствие бесконечных перезагрузок и удаления лишних файлов, случаем?
                                        –3
                                        Либо все, либо ничего — обыкновенная припадочная философия © Макаренко…

                                        Тут, знаете ли, «поля этой книги слишком узки»…

                                        Не то, что это невозможно доказать в принципе… но для формализации всех требований потребуется столько всего формально описать — что даже у Microsoft столько разработчиков нету.

                                        Но какие-то более простые вещи — вполне возможно.
                                          0

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

                                          –1
                                          как доказать отсутствие бесконечных перезагрузок

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


                                          удаления лишних файлов

                                          Тут уже сложнее, сначала надо определить, что такое лишний файл.


                                          Естественно, всё это требует полной формализации вообще всей системы, относиться к ОС как к некоему внешнему миру, корректность которого мы принимаем за аксиому, больше не получится.

                                          +2
                                          Ну, можно доказать, что программа никогда не удаляет файлы пользователя. Однако, функция удаления файлов пользователя нужна как минимум в антивирусе и ряде др.программ.

                                          Отсутствие «бесконечного цикла перезагрузок» надо доказывать не для каждой отдельной программы, а для совокупности программ, запускающихся при загрузке. А это уже на порядок сложнее.
                                          Хуже того: нигде нет гарантии, что набор программ, запускающихся при загрузке, будет нужным: м.б. так, что часть программ от новой версии, а часть от старой; или вообще каким-то образом туда влезло что-то постороннее. Как Вы понимаете, количество вариантов растёт экспоненциально, сложность доказательства становится непомерной.

                                          Частично помогает строгая изоляция программ — когда каждая программа имеет строго свою функцию и не может сделать ничего за её пределами. Но разделение функций — это вопрос не к языку программирования, а к архитектуре. В Windows — архитектура такова, что доказать можно лишь отсутствие изоляции. Хуже того — архитектура PC-совместимого компьютера такова, что до момента загрузки ядра операционки изоляция в принципе невозможна; а реально — изоляция становится возможной существенно позже загрузки и инициализации ядра. Так что доказуемая надёжность системы на ранних этапах старта — на данный момент в принципе недостижима.
                                          Ну и до кучи: строгая изоляция программ обязательно понижает эффективность работы.
                                            +1
                                            Ну, можно доказать, что программа никогда не удаляет файлы пользователя.

                                            Отлично, с этим критерием уже можно работать.


                                            Если сигнатура функции удаления выглядит как что-то в духе


                                            superCoolDelete : (path : FilePath) -> Not (UserFile path) -> Eff [Delete] ()

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


                                            Как формализовать понятие пользовательского файла и как написать эту функцию — уже другой вопрос, но идея, надеюсь, понятна.


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

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


                                            Хуже того: нигде нет гарантии, что набор программ, запускающихся при загрузке, будет нужным: м.б. так, что часть программ от новой версии, а часть от старой; или вообще каким-то образом туда влезло что-то постороннее. Как Вы понимаете, количество вариантов растёт экспоненциально, сложность доказательства становится непомерной.

                                            Вопрос в том, сколько из этих вариантов на самом деле достаточно уникальны.


                                            Так-то и количество вариантов чисел для утверждения (a + b) + c = a + (b + c), гм, большое, но доказать это свойство можно парой строк.

                                              +1
                                              Я бы начал с того, что пользовательская программа не должна приводить к перезагрузке компьютера (в самом деле, зачем?).

                                              А halt и shutdown это пользовательские программы? А когда кнопочка в «меню пуск» посылает сигнал системе о перезагрузке, это пользовательская программа? Я думаю да. Как без них то перезагрузить, питание дернуть?
                                                –1
                                                В нормально организованной системе (без известных костылей) программы halt и shutdown, разумеется, не было бы пользовательскими, а были бы частью системы. А уже кнопочка выключения могла бы посылать «запрос на перезагрузку» привилигерованной части системы — и та осуществляла бы перезагрузку с учётом опрделеённых правил и гарантий.

                                                Впрочем это всё — разговоры «в пользу бедных». Почему ваш телефон, с вероятностью 99%, поддерживает вывод данных на консоль через serial port? Потому что когда-то давно к компьютерам присоеденили телетайп, а потом… эта — работает не трогай…

                                                Никакой язык это не изменит…
                                                  –1
                                                  А уже кнопочка выключения могла бы посылать «запрос на перезагрузку» привилигерованной части

                                                  картошка — картофель
                                                  как не назови, сигнал или непосредственный вызов кода, а пользовательский софт инициализирует перезагрузку.
                                                  чтобы написать спецификацию ОС которая не будет косячить, надо придумать все возможные косяки.
                                                  Возьмем
                                                  superCoolDelete: (path: FilePath) -> Not (UserFile path) -> Eff [Delete] ()

                                                  *Интересное наблюдение, недавно 0xd34df00d'у скинули кусок кода, так он прокоментировал типа «я не совсем понимаю, потомучто не знаю язык», зато сам как не кусок кода, идрис, который никто не знает.
                                                  Вернемся к коду. Немножко изменим задачу, «защитить от случайного удаления файлов». Вспомним нвидиа и их скрипт который вместо
                                                  rm -rf /var/bla/bla/bla
                                                  сделал
                                                  rm -rf /var /bla/bla/bla.
                                                  От такого можно защитить? Например как? создать специальную rm1, которая примет только 1 аргумент? Больше вариантов не знаю. Но ведь чтобы это создать, надо сначала натолкнуться на такую проблему и понять что она имеет место быть.
                                                    0
                                                    Тут вы упираетесь в самую большую проблему любых тестов и любой типизации: вы можете защититься от известных проблем… но как защититься от неизвестных?
                                                      +2
                                                      как не назови, сигнал или непосредственный вызов кода, а пользовательский софт инициализирует перезагрузку.

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


                                                      чтобы написать спецификацию ОС которая не будет косячить, надо придумать все возможные косяки.

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


                                                      *Интересное наблюдение, недавно 0xd34df00d'у скинули кусок кода, так он прокоментировал типа «я не совсем понимаю, потомучто не знаю язык», зато сам как не кусок кода, идрис, который никто не знает.

                                                      Извините, что не расписал подробнее, что там происходит. Я с радостью отвечу (и стараюсь отвечать) на вопросы по тому типу.


                                                      От такого можно защитить? Например как?

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

                                                  0
                                                  Если сигнатура функции удаления выглядит как что-то в духе
                                                  superCoolDelete : (path : FilePath) -> Not (UserFile path) -> Eff [Delete] ()

                                                  то её не получится вызвать без аргумента, доказывающего, что по указанному пути не лежит пользовательский файл.
                                                  Ну а кто сказал, что невозможно удалить файлы иным способом? Например, какая-то программа Икс создаёт текстовый файл; а программа Игрек запускает shell и передаёт ему этот файл в качестве скрипта. Теперь надо доказать, что в скрипте не м.б. команды удаления файла с путём юзерского каталога. Я боюсь, тут мы попадаем на нереальную задачу, ибо shell явно не входит в число языков, комплментарных к доказующим системам.

                                                  Я бы начал с того, что пользовательская программа не должна приводить к перезагрузке компьютера (в самом деле, зачем?).
                                                  Вообще-то, программа shutdown — вполне пользовательская.

                                                  Или вот вариант, практиковавшийся в старых Windows (в W'XP точно, в остальных я не уверен; может, и сейчас есть): В ходе загрузки было обнаружено повреждение файловой системы. После исправления сбоев — система перезагружается, загрузка стартует заново.
                                                  Аналогично — система установки обновлений в Windows после установки некоторых обновлений (видимо, тех, которые затрагивают ядро и системные процессы) перезагружает систему.

                                                  Вопрос в том, сколько из этих вариантов на самом деле достаточно уникальны.
                                                  Если у нас стоит вопрос о доказательстве — то запросто уникальными м.б. все варианты.

                                                  Так-то и количество вариантов чисел для утверждения
                                                  (a + b) + c = a + (b + c)
                                                  , гм, большое, но доказать это свойство можно парой строк.
                                                  Ну, я с радостью посмотрю доказательство. Я-то всегда считал, что это — базовая аксиома алгебры.

                                                  Описанное Вами утверждение — достаточно простое в силу простоты составляющих его элементов и малого числа элементов в утверждении. Тогда как типичные программы содержат огромное количество простых элементов.
                                                    0
                                                    Например, какая-то программа Икс создаёт текстовый файл; а программа Игрек запускает shell и передаёт ему этот файл в качестве скрипта. Теперь надо доказать, что в скрипте не м.б. команды удаления файла с путём юзерского каталога. Я боюсь, тут мы попадаем на нереальную задачу, ибо shell явно не входит в число языков, комплментарных к доказующим системам.

                                                    Вы абсолютно правы, произвольный скрипт на шелле типизировать трудновато (Райс не даёт). Это значит, что в такой верифицированной системе не будет шелла, или будет какой-то ограниченный типизированный шелл (как turtle, но более выразительный, скажем?).


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

                                                    Прекрасный пример! Тут как раз такая уменьшающаяся мера очень легко придумывается: для программы исправления сбоев ФС выглядит разумным требование, что после её работы число сбоев меньше, чем до её работы (либо программа не может ничего починить, и тогда тоже можно обсудить, что делать). Тогда в предположении, что железо не сыпется и никто не тыкается паяльником в работающую машину, что-то тоже можно гарантировать.


                                                    Аналогично — система установки обновлений в Windows после установки некоторых обновлений (видимо, тех, которые затрагивают ядро и системные процессы) перезагружает систему.

                                                    Для адекватного механизма обновлений, думаю, тоже можно придумать аналогичную метрику. Не знаю, что там делает Windows при перезагрузках, но, например, можно предположить, что мера «число пакетов обновлений, которые осталось установить» тоже разумна.


                                                    Я-то всегда считал, что это — базовая аксиома алгебры.

                                                    Это зависит от того, что именно вы делаете.


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


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


                                                    Ну, я с радостью посмотрю доказательство.

                                                    Я собирался писать статью про физзбазз (не зря тут с неделю назад про него уже писали), и там бы это было, ну да ладно, кусочек можно и здесь привести.


                                                    Вы можете определить натуральные числа как


                                                    data Nat : Type where
                                                      Z : Nat
                                                      S : Nat -> Nat

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


                                                    Тогда операция сложения является производной операцией и определяется рекурсией, например, по первому слагаемому:


                                                    (+) : Nat -> Nat -> Nat
                                                    (+) Z y = y
                                                    (+) (S x) y = S (x + y)

                                                    Тогда доказательство ассоциативности происходит по индукции, двумя ветвями: базовый случай, когда первое слагаемое равно нулю (тогда всё тривиально из определения сложения), и индуктивный случай, когда можно воспользоваться доказанным фактом для предыдущего значения:


                                                    plusAssoc : (n, m, k : Nat) -> n + (m + k) = (n + m) + k
                                                    plusAssoc Z m k = Refl
                                                    plusAssoc (S n) m k = cong $ plusAssoc n m k

                                                    В частности, во втором случае нам нужно доказать S n + (m + k) = (S n + m) + k, что автоматически упрощается за счёт определения операции + (индукция идёт по тому же члену, по которому идёт рекурсия в операции сложения, неспроста) сначала в S (n + (m + k)) = (S (n + m)) + k, а потом в S (n + (m + k)) = S ((n + m)) + k). «Предположение индукции» даёт нам доказательство (n + (m + k)) = ((n + m) + k), а cong позволяет заключить, что если a = b, то f a = f b для любых f, a, b (применяя одну и ту же функцию к равным аргументам, мы получим равные значения).


                                                    Описанное Вами утверждение — достаточно простое в силу простоты составляющих его элементов и малого числа элементов в утверждении.

                                                    Важно, что все возможные состояния перечислять не нужно.

                                          +22
                                          В интересное время мы живем, некоторые идеи стали насаждать в головы настолько агрессивное, безапелляционно и грубо.
                                          Посмотрел на биографию Ryan Levick:
                                          I’m a developer advocate working in Berlin, Germany. I joined Microsoft via the acquisition of Wunderlist. I’ve spent my career building apps on the server and client side and exploring a wide range of open source technologies with a particular focus on functional programming.
                                          Skills:
                                          * Rust, JavaScript/TypeScript, Elm, Elixir
                                          * Functional programming
                                          * Software architecture
                                          * Software Education

                                          И меня смутило несколько аспектов:
                                          • Он инженер, разработчик, который был включен в микрософт поглощением другой компании заявляет от лица всей микрософт что будут использовать Раст?
                                          • В его профиле кроме раст JavaScript/TypeScript, Elm, Elixir больше ничего нет, он действительно может что-то с чем то сравнивать?

                                          Я понимаю, что молодому языку нужно пробивать себе дорогу в жизни, но тоньше работать надо, если людей долбить по голове будет просто секта. Если люди реально увидят пользу и захотят — будет новый С.
                                          Например — хочу я микроконтроллер на Риск5 и раст, все что у меня есть это россыпь GitHub репозиториев, бол-во устаревший, а другие как конструкторы. Код который будет генерировать компилятор должен быть надежный, я не могу потратить время отлаживая еще и генерируемый ассемблер.
                                          В общем что я хочу сказать текущему тренду на «вдалбливание, что раст могуч» — чтоб он действительно таковым стал уйдут годы и годы, мы состаримся, а потом он либо тихо умрет, либо так же тихо станет стандартом де-факто, но ни в 1 сценарии он не станет стандартом только потому что пользователей активно убеждают.
                                            +5
                                            Я понимаю, что молодому языку нужно пробивать себе дорогу в жизни, но тоньше работать надо, если людей долбить по голове будет просто секта.

                                            Что у нас там с сектой любителей картофеля? Картофель в России внедрялся давлением сверху, без особой тонкости, если что.


                                            Впрочем, картофельные бунты были, да.

                                              +2

                                              К чему может привести ставка на один картофель на все случаи жизни, вам могут рассказать ирландцы середины 19 века :) А вообще согласен с предыдущим оратором насчёт попыток агрессивного вдалбливания.

                                                +2

                                                Здесь аналогия работает скорее не в пользу C (и классическое: картошка не при чём, это неправильные ирландцы). Но я имел в виду то, что к сектантству такие ситуации имеют мало отношения, хотя многим почему-то хочется видеть это именно так.

                                                  +3
                                                  Ну это не я приравнял раст к картошке, а вы :) Вообще я уже давно говорю о том, что агрессивные попытки продвижения раста с помощью полуправдивых тезисов скорее отталкивают от языка, чем привлекают. Вот и в этой статье встречаются утверждения типа «но даже здесь небезопасные части заключены в безопасный API». А ведь это в лучшем случае wishful thinking, а в худшем — недобросовестная пропаганда. Если бы наружу unsafe-кода всегда торчал один только гарантированно безопасный API, то не было бы вот такого, например, или такого (и это только из свежего). Далее, в статье создается впечатление (не знаю, умышленно или нет), что статический анализ нужен только в C/C++, а в Rust достаточно одного лишь компилятора, но как-то умалчивается про утилиты типа clippy, а также про попытки реализации «более глубокой» верификации unsafe-кусков в рамках того же RustBelt, необходимость в которой, судя по вышеприведенным уязвимостям, очевидно, тоже имеется. Ну и зачем это? Складывается негативное впечатление именно такого рода, что в лице «продвигателей» раста имеешь дело с фанатиками, которые готовы при случае может и не то чтобы приврать, но тенденциозно осветить — точно. Меньше пафоса и пропаганды, и люди, может, активнее потянутся.
                                                    +8

                                                    Ну не знаю. Если один инструмент позволяет совершить 10 ошибок на N строк кода, а другой — только 1, то очевидно нужно выбирать второй. При этом никто не говорит, что вот совсем никаких ошибок не будет, это скорее всего невозможно. Но значительно уменьшить их количество вполне реально.


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

                                                      +1
                                                      Ну вот когда тот же Lau или я «узнают подробности», не только о плюсах, но и о минусах (ничего не дается бесплатно, те же граждане из RustBelt честно пишут, что «Unfortunately, none of Rust's safety claims have been formally investigated, and it is not at all clear that they hold. To rule out data races and other common programming errors, Rust's core type system prohibits the aliasing of mutable state, but this is too restrictive for implementing some low-level data structures», да и не только low-level тащем-та, весь дырявый unsafe-код из всех этих rustsec advisories тоже написан не от хорошей жизни, а в попытках создать что-то работающее в условиях, когда safe rust не позволяет этого сделать из-за ограничений дизайна), то как раз и создается то самое впечатление «чем больше вижу нечистоплотной рекламы, тем меньше шансов, что лично я к нему обращу свой взор».
                                                        +4
                                                        Граждане RustBelt часть работы уже давно провели plv.mpi-sws.org/rustbelt/popl18/paper.pdf

                                                        Ну и давайте до абсурда не доводить. У нас с одной стороны есть C/C++, которые вообще ничего не дают в плане безопасности. С другой у нас есть rust, который даже без формальной верификации чисто технически способен предотвращать кучу ошибок. Мы же не требуем формальной верификации о статических анализаторов, виртуальных машин со сборщиками мусора и прочими штуками, которые мы считаем безопасным. Умозрительно нам понятно, что они достаточно безопасны. Как бы, это уже огромный шаг вперед и этого достаточно, чтобы задуматься о переходе. Формальная верификация я даже не знаю кому реально нужна, если даже ядро ОС пишут без всяких верификаций и строгих стандартов кодирования. Отрасли, где на кону жизни людей, может быть повременят, хотя даже там используются все теже С/С++, обложенные кучей костылей, чтобы сделать их безопаснее.
                                                          0
                                                          К сожалению, «способен предотвращать кучу ошибок», которые относятся к одному типу (
                                                            +5
                                                            Не к одному. Раст предотвращает гонки данных, выходы за границы, висячие указатели, use-after-free и наверняка кучу еще других категорий ошибок.
                                                            Этого типа достаточно, чтобы исчезло подавляющее большинство CVE, которые обычно приводят или прямо к RCE, или повышению привилегий.
                                                              –6
                                                              Выходы за границы, контроль указателей, use-after-free, double-free, NPE — один класс(тип) ошибок.

                                                              Гонки данных, как недавно было продемонстрировано — не предотвращает. Ну или точнее, может и предотвращает для хелловорлдов, но не на реальных применениях (где мешает дизайн Раста).
                                                                +2
                                                                Вы что-то сами себе придумали (кстати, говоря уже далеко не первый раз). Pin там как раз и есть для того чтобы через типы запретить некорректные операции по работе с памятью во время await'ов.
                                                                  –1
                                                                  Не согласен. Посмотрев исходники и советы общества — и считаю, что это работает так:
                                                                  1. Pin держит для текущего потока указатель (ссылку), чтобы OB его не переместил (move, consume) или не удалил по концу лайфтайма
                                                                  2. Pin через unsafe отдает сырой указатель (ссылку) другому потоку или кому угодно, что тот с ним работал. Но ОВ второго потока ни сном ни духом про соперника.

                                                                  Итого это не заслуга языка, а простой костыль, аналогичный Memory.Pin в C#
                                                                    +2
                                                                    1. Pin держит для текущего потока указатель (ссылку), чтобы OB его не переместил (move, consume) или не удалил по концу лайфтайма

                                                                    Нет же. Pin оборачивает некий указатель на объект. Сам Pin можно перемещать, он требуется для того, чтобы через указатель нельзя было вытащить данные за указателем (при помощи, например, std::mem::swap). Это позволяет сохранять стабильный адрес объекта в памяти и, как следствие, хранить в объекте ссылки на себя.
                                                                    Для неудаления в конце времени жизни тоже есть тип, но это другой тип, ManuallyDrop, и он нужен совсем для других вещей.


                                                                    2. Pin через unsafe отдает сырой указатель (ссылку) другому потоку или кому угодно, что тот с ним работал. Но ОВ второго потока ни сном ни духом про соперника.

                                                                    Потоки тут не при чём. Pin может отдавать мутабельную ссылку на внутренности, и эта операция unsafe из-за того, что при этом можно вытащить объект из-за ссылки и потенциально инвалидировать самоссылающиеся объекты. Временем жизни Pin никак не управляет.


                                                                    С тем, что Pin — это костыль, никто и не спорит. Но это — естественное следствие того, что Rust разрабатывался как язык, в котором любое значение тривиально перемещаемо. Я не уверен, что это можно было бы сделать как-то получше, не сломав при этом обратную совместимость.

                                                                      0
                                                                      И я про то. Pin обходит OB для содержащегося указателя (кроме умеющих в Unpin, как я понял).

                                                                      Но вопрос был в том, что Раст предотвращает Датарейс, но если используем Pin — то нет.
                                                                        0
                                                                        И я про то. Pin обходит OB для содержащегося указателя (кроме умеющих в Unpin, как я понял).


                                                                        Pin обходит правила владения не больше чем Box. Вы же не будите, что из-за Box в расте возникают датарейсы?
                                                                      –4
                                                                      Я был неправ, но и Вы тоже. Просто у Pin есть разные специализации трейтов для &T и для &mut T.
                                                                      Из документации этого не видно — но по факу Pin(&T) не умеет в as_mut().
                                                                      В итоге, читая доку, я был обманут.

                                                                      Итоговый результат в этом треде — Раст предотвращает гонку данных между потоками. Но цена этого — вы не можете использовать общие данные между потоками в safe Rust. Никак!
                                                                        +3

                                                                        Вообще-то видно:
                                                                        image


                                                                        P: DerefMut означает, что можно получить мутабельную ссылку на содержимое P, что неверно, если P=&T. В этом можно убедиться, посмотрев реализации трейта DerefMut. DerefMut для &T там явно запрещён:
                                                                        impl<'_, T> !DerefMut for &'_ T

                                                                        +2

                                                                        Без синхронизации — действительно не можете и это хорошо. А если у вас данные Sync — шарьте сколько угодно.


                                                                        Из документации этого не видно

                                                                        Как же это не видно. Видите, какое ограничение на параметр P? Что-то, что может дать мутабельную ссылку. Просто для новичка возможно это не слишком очевидно, так ведь и Pin не новичкам нужен.

                                                                          0

                                                                          В документации это прекрасно видно, метод as_mut присутствует только в impl-блоке для тех P, которые реализуют DerefMut: https://doc.rust-lang.org/std/pin/struct.Pin.html#method.as_mut


                                                                          Но цена этого — вы не можете использовать общие данные между потоками в safe Rust.

                                                                          Это совершенно не верно. Как минимум можно использовать безопасные примитивы синхронизации. Также и без них можно шарить между потоками объект по статической ссылке.


                                                                          Ну а если вы подразумеваете, что в конечном итоге все равно где-то "под капотом" будет вызываться unsafe — то да, без этого не обойдется ни одна сколь-либо значимая операция. Я не могу взять объект из Vec по индексу или проитерироваться по массиву с тем, чтобы не стриггерить какой-нибудь unsafe-код. Ну и что с того?

                                                                            0
                                                                            Ну так DerefMut реализуют все примитивы.
                                                                            Это совершенно не верно. Как минимум можно использовать безопасные примитивы синхронизации. Также и без них можно шарить между потоками объект по статической ссылке.
                                                                            Можно пример?
                                                                      +3
                                                                      2. Pin через unsafe отдает сырой указатель (ссылку) другому потоку или кому угодно, что тот с ним работал. Но ОВ второго потока ни сном ни духом про соперника.


                                                                      Ну вот опять вы придумываете.

                                                                      Pin, как и другие смарт-поинтеры раста, не нарушает гарантии, которые предоставляет раст для своего safe подмножества и не передает никакие указатели в другие потоки сам по себе.

                                                                        –2
                                                                        Конечно, другие потоки сами виноватые — сами попросили
                                                                            pub fn as_mut(&mut self) -> Pin<&mut P::Target> {
                                                                                // SAFETY: see documentation on this function
                                                                                unsafe { Pin::new_unchecked(&mut *self.pointer) }
                                                                            }
                                                                          +3

                                                                          Кек. Если у вас на руках есть &mut-ссылка, то у вас уже заведомо доступ к Pin есть только из одного потока. Это на этапе компиляции проверяется.

                                                                            0
                                                                            Я ж этот пример из async/await принес…
                                                                              +1

                                                                              И? В каждый момент времени с конкретной футурой всё равно максимум один поток работает.

                                                                                0
                                                                                Да, у меня не получилось опасно расшарить содержимое Pin на два потока — хотя он и отдает внутреннюю ссылку, но сам объект Pin под контролем ОВ.
                                                                            +1
                                                                            Ну? Вы ведь даже скопировали нужный комментарий вместе с кодом. Нужно посмотреть документацию

                                                                            For correctness, Pin

                                                                            relies on the implementations of Deref and DerefMut not to move out of their self parameter, and only ever to return a pointer to pinned data when they are called on a pinned pointer.

                                                                              0

                                                                              Тем не менее, получается, что "благодаря" Pin сочетание safe Rust + standard library может приводить к BC. И это закрыли без фикса: https://github.com/rust-lang/rust/issues/66544

                                                                                +1
                                                                                Как закрыли без фикса? А это что тогда?
                                                                                  0

                                                                                  Это точно полный и окончательный фикс? Я не вижу как он может предовратить имплементацию DerefMut, перемещающую self куда-нибудь. Или, например, меняющую местами две части self, которые отдаются в норме только через Pin (structured pinning это называется, кажется).

                                                                                    +1
                                                                                    Я не вижу как он может предовратить имплементацию DerefMut


                                                                                    Как-то так

                                                                                    Вообще, вопросы, связанные с Unsoundness для Pin действительно не простые. Если вы не согласны с фиксом, то думаю, гораздо продуктивнее будет написать сразу в указанную вами issue.
                                                                            –2
                                                                            Я читал доку, а там не всё.

                                                                            Кстати, на моей [длинной] памяти это первый язык, нарушающий правило — хороший код — самодокументированный.

                                                                            В Расте комментарии документирования превышают код втрое
                                                                              +2

                                                                              Из того, что в std Rust хорошо все задокументировано, как вы делаете вывод, что код там не самодокументированный? По-вашему в дополнении к самодокументированному коду невозможно написать хорошую документацию?

                                                                                –3
                                                                                не нужно. а программисты по дефолту ленивые
                                                                                  +3
                                                                                  Это уже какой-то маразм. Вы пытаетесь поставить в виду языку наличие удобной функции документирования в языке и то что программисты этой функцией пользуются правильно, приводя примеры использования кода и поясняя граничные случаи.
                                                                                    –4
                                                                                    Да какие претензии к языку? Просто наблюдение.

                                                                                    А вот комментарии к Pin, которых я вдоволь начитался вчера, доставляют
                                                                                    • Notice that this guarantee does *not* mean that memory does not leak!
                                                                                    • The following implementations aren't derived in order to avoid soundness issues..
                                                                                    • this method is safe because..(много повторений)
                                                                                    • This constructor is unsafe because we cannot guarantee that...
                                                                                    • This function is unsafe. You must guarantee...(несколько шт)
                                                                                    • we just need to take care not to allow such impls to land in std

                                                                                    Но главное, что работает :troll:
                                                                  –2
                                                                  Отрасли, где на кону жизни людей, может быть повременят, хотя даже там используются все теже С/С++, обложенные кучей костылей, чтобы сделать их безопаснее.
                                                                  Нет. В ядерной энергетике и авиации используют Ada, Ravenscar profile, SPARK. С программами на С/С++ предпочитают дела не иметь.
                                                                    +2
                                                                    Работаю в авиации, разрабатываю ПО по DO-178C/B на С++.
                                                                    Также, например, safety-critical ПО на недавно отшумевшем Crew Dragon написано на С++. Так что, мне кажется, вы слишком категоричны.
                                                                      +1

                                                                      Разве в таких случаях не используют сильно ограниченное подмножество языка, запрещают некоторые конструкции (рекурсию, бесконечные циклы) и снижают динамическое выделение памяти к абсолютному минимуму? Или для C++ какие-то из требований MISRA C можно ослабить?

                                                                        0
                                                                        Есть Misra C++, а для авиа — вообще свой стандарт (не помню). Для автопрома есть AUTOSAR, для встройки — тоже ESCR.

                                                                        Конечно, это все наборы запретов.
                                                                      +1
                                                                      Мед сектор, хирургия, мало-инвазивные операции — С микроконтроллепры и драйвера, С++ обвязка повыше.
                                                                      С/С++ это индустриальный стандарт сейчас и уже давно.
                                                                +1
                                                                Список CVE Microsoft
                                                                www.cvedetails.com/vulnerability-list/vendor_id-26/Microsoft.html
                                                                и список CVE в The RustSec Advisory Database
                                                                rustsec.org/advisories

                                                                как бы намекает, и на данный момент не идет ни в какое сравнение.
                                                                Ошибок «не может не быть», но если кому-то хочется их много, то это дело «хозяйское», насильно мил не будешь…
                                                                  +1
                                                                  Объем кода, написанного на Rust и на всем остальном, тоже не идет ни в какое сравнение, зачем же передергивать так откровенно? Вот это и называется «попытка продвижения с помощью полуправдивых тезисов»… Не делайте так. Пока все, что можно здесь утверждать — это то, что в коде на Rust вполне себе существуют все те же самые классы ошибок, что и в коде на C/C++, просто потенциальные места их возникновения пытаются обозначить флажками, что, как видно, далеко не всегда помогает, учитывая ограниченность дизайна safe Rust и кунштюки, на которые идут (возможно, вынужденно) некоторые разработчики на Rust.

                                                                  P.S. Тезис «Rust выбирают „любимой женой“ ПЯТЫЙ год подряд» тоже как бы… такой. Я, например, ни разу не голосовал там ни за какой язык, мне есть, чем заняться кроме этого, а представители пресловутой Rust Evangelism Strike Force просто более организованны и активны в этом плане, ходят строго в ногу, долбят одни и те же сомнительные тезисы из статьи в статью пополам с маркетинговым булшитом в стиле «a fundamental break in the history of technology», и что с того? Да ничего.

                                                                  Ладно, не интересно, все это уже жевано-пережевано уже много раз, принимать участие в дальнейшей дискуссии на эту тему никакого желания у меня нет, я уже наперед знаю все аргументы всех сторон :)
                                                                    +2
                                                                    ограниченность дизайна safe Rust

                                                                    Для обеспечения доказуемой корректности программы можно или ограничить возможности языка или обязать программиста писать доказательства вручную. В Rust выбрали первый вариант. Вряд ли это можно назвать ограничением дизайна языка.


                                                                    Есть ограничения текущей реализации borrow checker, которая не пропускает некоторые корректные программы, это — да.

                                                                      +1
                                                                      Для обеспечения доказуемой корректности программы можно или ограничить возможности языка или обязать программиста писать доказательства вручную.

                                                                      Даже во втором случае будут семантически корректные, но нетипизируемые программы.

                                                                      +1
                                                                      Передергивание — это высказанное тут, «да я помню как в 90-х агрессивно толкали java, а сейчас еще похлеще...». Я начал с Явой в 2000-2001 тогда и интернет был — так себе, не то что сейчас, так чтобы «агрессивно рекламировать» (как утверждается в комментах) было не очень то и легко. И поднялась Java в основном на адаптации в сервер-сайд-е.

                                                                      Вот тут не то что передергивание, а откровенное вранье — кто ж там вас проверит как было в 90-х?? В 1995 — FIDO net был еще вполне живой и бодрый, я то помню, а инет могли позволить себе далеко не везде.

                                                                      Так что зря тут была написана откровенная ложь, относительно «рекламирования» и аппелирование о «какой то там не доказательности».
                                                                      … просто потенциальные места их возникновения пытаются обозначить флажками..

                                                                      Еще одно ложное утверждение.
                                                                    –1
                                                                    Я бы даже добавил так.
                                                                    Эти агрессивные сторонники Rust дошли до того, что ПЯТЫЙ год подряд на StackOverflow выбирают его в «любимые языки». Вот где источник максимальной агрессии! Тут уже никак не поспорить…
                                                                      0
                                                                      Знаете — это даже не смешно. Да, Rust пятый год подряд «любимый язык StackOverflow». Но взаправду считаете, что на StackOverflow так мало голосующих, что горсточка любителей Rust может всё испортить?

                                                                      Может вы ещё и верите в том, что что Путин за $100'000 Трампа президентом сделал?
                                                                        –1
                                                                        Не, там у голосующих уровень агрессии гораздо выше, чем на жалкие 100К за Трампа (хотя а не знаю).
                                                                0
                                                                Возможно сравнивать картофель+крестьян против технологии и инженеров не совсем корректно.
                                                                Плюс картофель свою нишу действительно завоевал и не только в России, не будь он выгодным для людей на деле, он бы тихо скончался на обочине истории.
                                                                Я вам приведу пример — еще года 3 назад когда меня стали со всех сторон бомбардировать статьями какой прекрасный язык Раст, я честно пошел и изучил предмет.
                                                                Но в изучаемом материале было больше паблик-релэйшиншип и рекламы нежели инженирии.
                                                                Одно заявление, что Мозилла доверяет расту, но тихо умалчивая, что в ее же недрах его и сделали — стоит многого и показывает какими приемами готовы пользоваться люди продвигающие Раст в массы.
                                                                Я желаю Расту удачи, но чем больше вижу нечистоплотной рекламы, тем меньше шансов, что лично я к нему обращу свой взор. Потому что если меня пытаются дурить вот здесь — то где еще и сколько мне это будет стоить когда мой микроконтроллер в поле перестанет работать?
                                                                  +5
                                                                  Но в изучаемом материале было больше паблик-релэйшиншип и рекламы нежели инженирии.

                                                                  О каких материале речь? В своё время, изучал язык по раст-буку, rust by example и растономикону. В первом ещё можно найти признаки рекламы, но с другой стороны, мало какая книга о языке обойдётся без хвалебных эпитетов. Растономикон так вообще состоит чисто из технических подробностей.

                                                                    +4
                                                                    Одно заявление что Мозилла доверяет расту, но тихо умалчивая что в ее же недрах его и сделали стоит многого и показывает какими приемами готовы пользоваться люди.

                                                                    Ну, вообще-то изначально Rust был проектом Грейдона Хоара, и разрабатывался несколько лет перед тем, как его разработку начала спонсировать Mozilla.

                                                                      +2
                                                                      А вы уже забыли, как пиарили Java, когда оно только родилось на свет? Тогда эта технология находилась на зачаточном уровне, да и мощности железа были слабоваты. Тогдашняя древняя JVM была тормознутым лагуче-падучим монстроподобным угрёбищем. Даже просто запустить jar-приложение было той ещё задачей! До сих пор помню то первобытное шаманство с подбором версий JRE и их настройкой. Даже была такая расхожая шутка: мол, Java — по-настоящему кроссплатформенная технология, абсолютно везде НЕ работает совершенно одинаково.
                                                                      В общем, по тем временам всё выглядело настолько убого, что пользоваться этим дерьмом мог либо мазохист, либо сумасшедший.
                                                                      Но как же её пиарили! Java представлялась чуть ли не как новый виток развития ни много ни мало человеческой цивилизации! Пиар настолько зашкаливал, что за свою жизнь я потом всего однажды встречал нечто подобное (и это был момент выхода первой книги про Гарри Поттера). Право же, реклама Rust и рядом не стоит с тем уровнем упоротости и агрессивности, с которым продвигалась Java в середине 90-х.
                                                                        +3
                                                                        Я даже помню реакцию небезызвестного Спольски на все это пиар-безумие:

                                                                        And don’t even remind me of the fertilizer George Gilder spread about Java:

                                                                        A fundamental break in the history of technology…

                                                                        That’s one sure tip-off to the fact that you’re being assaulted by an Architecture Astronaut: the incredible amount of bombast; the heroic, utopian grandiloquence; the boastfulness; the complete lack of reality. And people buy it! The business press goes wild!
                                                                          +1

                                                                          Говоря по правде, Java в своё время была действительно прорывом. Особенно, когда вышел Hotspot, тогда и произошла смена парадигм, C++ начал стремительно вытесняться из бизнес-сектора.

                                                                            +1
                                                                            Вот только HotSpot — это уже ближе к XXI веку, а дикий, просто-таки зашкаливающий Хайп был вокруг Java с самого начала.

                                                                            JavaStation ведь в Sun на полном серьёзе разрабатывали.

                                                                            И, потом, не в HotSpot дело. Что там у нас было актально, когда вокруг Java хайп начался? Pentium на 120MHz да MicroSPARC на 100Mhz?

                                                                            Ну с эмулятором MicroSPARC я не знаю, но точный эмулятор Pentium на 120Mhz найти не проблема.

                                                                            Можете взять любые свои HotSpot'ы и убедиться что на том железе, вокруг которого разводили хайп — Java, по прежнему, практически невозможно использовать.

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

                                                                            P.S. Правда по итогу компания, которая это всё затеяла в надежде, что ей удастся сделать самые быстрые процы и заработать за счёт Java-тормозов кучу денег — сделать этого не смогла и, в конечном итоге, сгинула… но то такое: карма — страшная вещь…
                                                                              +1

                                                                              Дело было именно в Hotspot, и в удобстве разработки для серверов. Я в соседнем сообщении писал, что тот факт, что разрабатывать можно было на относительно слабых машинках (как правило Win 95 и позже 2k), а запускать на самых настоящих серверах, при этом не тормозя эти самые сервера -- вот это и обеспечило стремительное вытеснение C++.
                                                                              Даже сейчас писать кроссплатформенный C++ трудновато, а тогда у тебя максимум была ACE, wxWidgets и крутись как хочешь, никаких бустов. Ошибки, связанные с различием между разработческим и прод окружениями были нормой, и они зачастую были весьма нетривиальны.

                                                                              +1
                                                                              И появились шутки вроде «если бы в Java была действительно корректно реализована сборка мусора, большинство программ удаляли бы себя сразу после запуска» :) Ну так-то да, у Java, безусловно, есть ряд плюсов по сравнению с C++, которые делают ее минусы не столь важными в определенных областях, с этим трудно спорить. Но, честно говоря, на момент ее появления чисто технически «прорывом» она не была, даже, я бы сказал, наоборот. Технология сборки мусора на тот момент была вполне известна, технология bytecode VM тоже (еще с 70-х годов), синтаксис Sun в значительной степени позаимствовал у тогдашнего C++ (хорошенько его обкорнав, по их собственному заявлению «While Java superficially like C and C++, Java gained its simplicity from thesystematic removal of features from its predecessors»). Да, потом, когда ее основательно допилили, добавили реально работающий JIT и так далее (да и параметры доступного железа подросли, куда ж без этого, ага) в определенных областях и задачах за нее ухватились. Но пушили-то ее «будь здоров» со всеми полагающимися баззвордами еще задолго до этого.
                                                                                +1

                                                                                А я не зря упомянул Hotspot, до него к Java относились с большим пренебрежением, видя насколько сильно падала производительность. А с ним у многих сразу многие увидели, что на этом можно делать проекты.
                                                                                Да, и GC, и JIT компиляция, и VM были известны до этого, но предоставить всё это в одной удобной упаковке, с хорошей стандартной библиотекой, при этом разрабатывать можно было на относительно слабых машинках (как правило тогда сидели под виндой), а запускать на самых настоящих серверах — вот это всё впервые дала Java.

                                                                                  0
                                                                                  Да, похоже вы правы. Linux-сервера и возможность не мучиться с «самыми настоящими серверами» — это уже середина-конец нулевых, к этому поменту Java уже укоренилась достаточно сильно для того, чтобы её так просто нельзя было выкинуть…

                                                                                  То есть затея Sun, в принципе, удалась, просто к 10м годам большие сервера тупо «выдохлись»: люди научились в распределённые системы, стала важна не просто максимальная скорость, а «скорость на доллар» — а по этому показателю «настоящие сервера» никогда и близко не приближались к x86…
                                                                      +18

                                                                      Честно говоря, не вижу проблем с "пиаром". Если об языке не говорить, то о нём никто и не узнает. В своё время, заинтересовался как раз из-за срачей на одном форуме. Ну и да, это часть продвижения. Языков нынче много, конкуренция большая: приходится и доступные учебные материалы предоставлять и над качеством документации работать. Ну и да, рекламироваться — как с любым другим продуктом.


                                                                      Кстати, забавный момент: не будет ведь кто-то предполагать, что мозилла проплатила майкрософту за рекламу? А если контора, которая сама может создавать языки (и успешно это делает), хвалит чью-то стороннюю разработку, то это очень даже положительная характеристика, как по мне.


                                                                      "Стандартом де-факто" стать не так просто и далеко не всегда на это влияют чисто технические причины. Возьмём, к примеру, swift — язык неплохой, но если бы он не был официальным языком для яблочных платформ, то какая у него была бы доля? Или тот же С#. Или даже котлин — за ним не стоит мега-корпорация со своей платформой, но когда к языку сразу прилагается отличная ИДЕ, то это тоже намного облегчает порог входа.


                                                                      Опять же, если вместо "болтовни" майкрософт (или кто угодно) начал "насильно" внедрять раст, то недовольных было бы не меньше, хотя казалось бы.


                                                                      который был включен в микрософт поглощением другой компании заявляет от лица всей микрософт что будут использовать Раст?

                                                                      Подозреваю, что кому попало делать заявления от лица компании не разрешают.

                                                                        +2
                                                                        Подозреваю, что кому попало делать заявления от лица компании не разрешают.

                                                                        В рамках грустного юмора: зато кто попало считает себя вправе делать заявления от лица компании.
                                                                        Кажется, в статье описан не такой случай, просто грустное наблюдение.
                                                                          –1
                                                                          Я вижу проблему с пиаром, когда продажники и прочие активисты делают заявление А я воспринимаю это как рекламу и не более, то что нужно еще 10 раз проверить. Когда инженеры, которые по определению должны оперировать фактами и цифрами транслируют то же заявление А, безапелляционно заявляя о безопасности я первым делом думаю «вау, это реально круто».
                                                                          Но спустя несколько месяцев и пару книжек я понимаю что у этого заявления А должен был быть мелкий шрифт о котором забыли (не просто напечатали мелким, но нарочно забыли — мы же не будем на каждом углу об этом говорить как заявили выше), то у меня появляется чувство что что-то пошло не так и доверие которое было вначале падает до отрицательных величин.
                                                                          А далее происходит еще интереснее трансформации — инженеры которые говорят о прогрессивности раста мной начинают восприниматься как продажники, а не как инженеры, а чем больше повторяется тезис А, тем больше напоминает секту.
                                                                          Сколько было этих статей про безопасность, о скорости, о красоте и прочем. Там ведь даже мелкого шрифта не было, а ведь это не рекламные брошюры это материалы для инженеров.
                                                                            +3
                                                                            Послушайте оригинальное видео, чтобы оставить свои надуманные инсинуации.
                                                                            В видео с которого была написана оригинальная статья — там все сказано Левиком.
                                                                            И в свете этого ваши крайне надуманные глупости выглядять слегка убого, видно что вы не пытались и не будете его слушать. Более того, Левик в конце отвечает на задаваемые в чате вопросы.
                                                                            Ей богу, ваши потуги выглядят совсем «не в тему».
                                                                              –1
                                                                              Т.е. вы отрицаете, что у раста есть агрессивное продвижение, которое идет в разрез с принципами инженерного подхода?
                                                                                +2
                                                                                Понимаете… вы пытаетесь утверждать то, о чем Левик не говорит. И ваши голословные утверждения тоже «идут в разрез с принципами инженерного подхода», а Левик говорит о вещах которые точно знает, может утверждать и может себе позволить говорить.
                                                                                  –2
                                                                                  Небезопасный код в Rust почти всегда является подмножеством большего объема безопасного кода.

                                                                                  В исходнике:
                                                                                  Unsafe Rust code is almost always a subset of a larger body of safe code.

                                                                                  Видимо, Левик пытался сказать, что небезопасный (ну т.е. просто — опасный) код составляет малую долю от всего кода.
                                                                                  А получилось противоречивое высказывание.
                                                                                  Ему бы теорию множеств подучить.

                                                                                  Correctness в переводе — безошибочность, правильность.

                                                                                  Они быстрые, только с ассемблером между кодом и самой машиной.
                                                                                  It is fast, with the only assembly between the code and the machine itself.
                                                                                  Совсем плохой перевод.
                                                                                    0
                                                                                    Прямая речь, живая, заранее не писанная и заранее продуманная. Так что… как он сказал — так и сказал. Не вижу проблемы, это «живая речь» в видео-конференции, с неоконченными или не до конца завершенными предложениями, не всегда «синтаксически правильными» и т.д… Общая мысль и смысл его утверждений, предположений от этого не меняется, то что он ХОТЕЛ сказать, он СКАЗАЛ.
                                                                                    А тут масса народу развела «песню АНЫКАНА про агрессивную рекламу» — у таких все в порядке с логикой или видят только «заговор» ??? :)))
                                                                                  +9

                                                                                  А можно озвучить эти самые "принципы инженерного подхода"? Как вообще связаны эти две штуки: "инженерный подход" и "агрессивное продвижение"?


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


                                                                                  То, что у языка есть продвижение и он на слуху, это разве плохо? Может это только моё видение, но мне кажется, что основной хайп вокруг Rust создаётся сарафанным радио, то есть самими пользователями, которые устали от проблем в широкоиспользуемых языках программирования, они попробовали или перешли на Rust и теперь хотят рассказать об этом всему миру.

                                                                                    –4
                                                                                    Самое большое «припекание» — у фанатов всяких F# и Haskell. Которые просто вне себя от бешенства, когда Rust продвигают как «безопасный» язык — хотя это «нифига не так» (библиотеки полны unwrap и unsafe… какой же это, нафиг, безопасный язык?).

                                                                                    Понять, что безопасность — это, простите, не bool и даже не скаляр, что у безопасности — много измерений… они, почему-то, не в состоянии.

                                                                                    Ну вот так же, как и фанаты OpenBSD, на самом деле. Если что-то повышает безопасность и этого у вас в операционке нету — то там «не безопасность, а дерьмо».

                                                                                    А тот факт, что операционка, кроме того, чтобы быть безопасной, должна быть полезной… и то же самое — с языком… этого они, почему-то, понять не в состоянии.
                                                                                      +2

                                                                                      Что-то вы в каком то другом мире живете, основное припекание я видел от людей с Си++ головного мозга. Хаскелисты вообще выше всего этого, как мне кажется.

                                                                                        –1
                                                                                        Ну «царей сишечки» я вообще выношу за скобки: если человек невменяем, то с ним что-либо обсуждать бессмысленно.

                                                                                        А как раз людей, умеющих в C++, типа 0xd34df00d а Rust особо и не напрягает…
                                                                                          0

                                                                                          С одной стороны, от заголовка этой статьи лично мне немножко припекло (раст и безопасные системы? они там слышали про коки-агды-идрисы?). С другой стороны. с допиской во втором-третьем абзаце о производительных и низкоуровневых системах это начинает иметь какой-то смысл.

                                                                                            +5

                                                                                            Ну вообще в плане безопасности Rust тут весьма узкую проблему решает, хотя и очень популярную. Количество сегфолтов, когда я перешел на раст, действительно серьезно упало по сравнению с плюсами, причем оставшиеся почти все оказались связаны с FFI, а остальные с моими кривыми руками при написании unsafe блоков кода, которых я не так уж и много настрочил.


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

                                                                                              +1
                                                                                              У Раста много хороших сторон, но вот макросы — непонятно зачем второй язык, и с модульностью я, например, что то не понимаю — в каком, ска файле искать тот или иной трейт для типа!? Теряю много времени просто на поиск исходника.
                                                                                              Файловая и именная иерархия Явы и прочих более удобна.
                                                                                                0
                                                                                                в каком, ска файле искать тот или иной трейт для типа!?

                                                                                                Либо там, где объявлен трейт, либо там, где объявлен тип, разве нет? Это в хаскеле вы можете orphan-инстансы объявлять и ограничиться ворнингом, а в расте вроде как вообще нельзя так делать.

                                                                                                  0
                                                                                                  Нет, к сожалению.

                                                                                                  Предлагаю засечь время чтобы найти описание (повторить мой пусть)
                                                                                                  heapless::consts::U9
                                                                                                    0

                                                                                                    Один клик в IDE? (:

                                                                                                      0
                                                                                                      Время засёк?

                                                                                                      Теоретиков много.
                                                                                                      +1

                                                                                                      IDE открывать было лень, поэтому пользовался гитхабом и кликами. Заняло с минуту. Зашёл в heapless/lib.rs увидел, что consts — это реимпорт из typenum/consts.
                                                                                                      И прямо в доке typenum/consts второй строкой написано, что эти константы генерятся во время билда, так что в исходниках их нет, есть только кодогенерация. Ну и в целом описание этих констант там прямо в доке.
                                                                                                      В расте я новичок, если что — опыта на 2 kloc + активное чтение статей и чужого кода.


                                                                                                      В общем, не знаю, к чему именно у вас претензии — если к кодогенерации, то смысла не вижу. А если к тому, что для typenum она вообще нужна, то тут да, проблема молодости языка присутствует. Const generics в разработке, и с ними весь этот бойлерплейт вроде можно будет выкинуть.


                                                                                                      Если говорить чуть глобальнее касательно вашего вопроса "непонятно что где искать", то я в целом могу согласиться, мне тоже порой непривычно что операция A над B может быть реализована за счёт импорта трейта C, потому что там дженерик хитрый. Мне кажется, это дело привычки, и то что раст не очень дружелюбен к новичку — довольно известная тема.


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

                                                                                                        0
                                                                                                        т.е так и не нашел. не ОК, а я предлагал таки найти…
                                                                                                        и это не кодогенерация
                                                                                                          0

                                                                                                          Наверное, я не очень понимаю, что значит "найти". Найти вот это https://docs.rs/heapless/0.5.5/heapless/consts/type.U9.html или вот это https://docs.rs/typenum/1.12.0/typenum/consts/type.U9.html (что в общем-то одно и тоже)? Или найти как с этим работать (т.е. почитать доку к typenum)? Или что-то ещё?

                                                                                                            0
                                                                                                            Найти в исходниках heapless описание типа.

                                                                                                            А какую Вам информацию дало найденное описание? =)

                                                                                                            typenum тут ни при делах
                                                                                                              +1

                                                                                                              Боюсь, я не согласен с тем, что это не кодогенерация (т.к. противоположное написано прямо в документации), да и вот та самая строка файла генератора, где создаётся определение типа https://github.com/paholg/typenum/blob/master/build/main.rs#L168
                                                                                                              С другой стороны я также не понимаю, что не так с моим ответом, т.к. определение типа я вам нашёл прямо в doc.rs (а куда ещё идти за этим если не туда?)


                                                                                                              type U9 = UInt<UInt<UInt<UInt<UTerm, B1>, B0>, B0>, B1>;

                                                                                                              Собирать локально heapless и делать скриншот из сгенерированного файла мне пожалуй не хочется.


                                                                                                              Возможно мы с вами просто говорим на разных языках, но я искренне не понимаю ваших выводов.

                                                                                                                –6
                                                                                                                Еще раз. Я просил код из heapless::, НЕ из typenum — там совсем другое
                                                                                                                  +3

                                                                                                                  И раз: https://github.com/japaric/heapless/blob/master/src/lib.rs#L79


                                                                                                                  pub use generic_array::typenum::{consts, PowerOfTwo};

                                                                                                                  И два: https://github.com/fizyk20/generic-array/blob/master/src/lib.rs#L78


                                                                                                                  pub extern crate typenum;

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

                                                                                                                    0
                                                                                                                    Приношу некоторые извинения — на больную голову я неверно поставил задачу ;-(

                                                                                                                    В общем искать надо мне было не U9, а String<U9>. и с большим трудом обнаружил, что это формируется макросом.
                                                                                                                      +1

                                                                                                                      Но это же не макрос.

                                                                                                                        0
                                                                                                                        Ниже на 2 строки
                                                                                                                        macro_rules! impl_from_num {
                                                                                                                            ($num:ty, $size:ty) => {
                                                                                                                                impl<N> From<$num> for String<N>
                                                                                                                        
                                                                                                                        Правда, я не понял, каким образом, без явного его вызова формируется нужный мне String<U9>
                                                                                                                          0

                                                                                                                          Этот макрос в самой heapless раскрывается в такую конструкцию:


                                                                                                                          impl<N> From<u8> for String<N>
                                                                                                                              where
                                                                                                                              N: ArrayLength<u8> + IsGreaterOrEqual<U4, Output = True>,
                                                                                                                          {
                                                                                                                              fn from(s: u8) -> Self {
                                                                                                                                  let mut new = String::new();
                                                                                                                                  write!(&mut new, "{}", s).unwrap();
                                                                                                                                  new
                                                                                                                              }
                                                                                                                          }

                                                                                                                          (и аналогично для других пар, перечисленных ниже). Далее, при наличии реализации From for U, автоматически генерируется реализация Into в обратную сторону. Как следствие, в Вашем коде можно написать:

                                                                                                                          let num: u8 = ... // как-то получили число
                                                                                                                          let string: String<N> = num.into();
                                                                                                            +2
                                                                                                            Знаете — у нас в репозитории и половину классов в проекте на C++ найти нельзя. Потому что кодогенерация. Это точно проблема C++? Как решать предлагаете?

                                                                                                            P.S. Кстрати предложенное вам решение: ткнуть в IDE и посмотреть — отлично работает и в C++ и в Rust. Да, оно приведёт вас куда-то в недра сгенерированного файла, но займёт это меньше секунды в обоих случаях.
                                                                                                          +1

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

                                                                                                            0

                                                                                                            Ну, справедливости ради, с реэкспортами это действительно не всегда тривиально — в примере выше попасть из документации к heapless в документацию к typenum мне, например, не удалось.

                                                                                                              +1
                                                                                                              Реэкспорты идут в паре с пространствами имён всегда. Даже если вот прям сразу после появления их нету — их через несколько лет добавляют.

                                                                                                              А жить без пространств имён… как в С… не знаю — это лекарство, которое хуже болезни IMO…
                                                                                                      +2
                                                                                                      У Раста много хороших сторон, но вот макросы — непонятно зачем второй язык, и с модульностью я, например, что то не понимаю — в каком, ска файле искать тот или иной трейт для типа!? Теряю много времени просто на поиск исходника.

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


                                                                                                      Файловая и именная иерархия Явы и прочих более удобна.

                                                                                                      Не уверен. Собственно, главное, что нужно понять в системе модулей Rust — это то, что объявление модуля располагается не в самом модуле, а в родительском модуле. Это позволяет построить всё дерево DAG модулей, имея доступ только к корневому модулю, вне зависимости от того, как они реально располагаются в файловой структуре. И не надо по файлу на модуль делать.

                                                                                                        0
                                                                                                        Хотелось бы понять основополагающий принцип.

                                                                                                        Локально я и grep'ом поищу, хотя кстати иногда не сработает — макросы.
                                                                                    +2
                                                                                    А что вас смущает? Выстрелит идея, отлично, не выстрелит, уволят и скажут, что к самому майкрософту он отношения не имеет и от лица всей компании заявлений делать не мог.
                                                                                      +2
                                                                                      я тоже хочу микроконтроллер на RISC-V и Rust. точнее, хотел когда-то.
                                                                                      а прямо сейчас у меня есть и риск5 контроллеры разных моделей и пишу нативный код для них на расте. инструментов для разработки уже достаточно.
                                                                                      бывает, что подглядываю в исходники на Си, но это касается только переписывания драйверов подключаемых устройств и пробелов в их документации.
                                                                                        +3
                                                                                        Он инженер, разработчик, который был включен в микрософт поглощением другой компании заявляет от лица всей микрософт что будут использовать Раст?
                                                                                        Да, представьте себе. Иногда бывает полезно смотреть не только вглубь, но и, собственно, на поверхность предмета тоже.

                                                                                        Вы тут покопали и установили, что, исходя из опыта человека, он однозначно пропогандировал бы Rust — независимо от того, где он работал бы. И это — полезна информация.

                                                                                        Однако же покупка Wunderlist случилась пять лет назад. Все сроки, которые могли быть по типичным контрактам — давно вышли.

                                                                                        А этого человека не только не уволили, но поставили на должность «developer advocate» (да-да, представьте себе — это оффициальное название должности).

                                                                                        Что это говорит нам о позиции Microsoft в отношении Rust?

                                                                                        В его профиле кроме раст JavaScript/TypeScript, Elm, Elixir больше ничего нет, он действительно может что-то с чем то сравнивать?
                                                                                        А почему он дожен что-то с чем-то сравнивать? Задача «developer advocate» — не сравнивать что-то с чем-то объективно. Задача developer advocate — продвигать ту технологию, которую скажут (как правило он должен в эту технологию ещё и сам верить, иначе продвигать плохо получается, но это, строго говоря, не обязательно). А вот продвигать только те технологии, в которые верит нанявшая тебя компания — это обязательно.

                                                                                        Тут как с рекламным агенством: если рекламный агент говорит «наши кроссовки — самые лучшие в мире», то он лично, может быть, так и не склонен считать… но компания, которая его наняла — так считает точно (ну или, как минимум, хочет, чтобы вы так считали). И даже неважно — где он до этого работал и что он рекламировал.

                                                                                        В общем что я хочу сказать текущему тренду на «вдалбливание, что раст могуч» — чтоб он действительно таковым стал уйдут годы и годы, мы состаримся, а потом он либо тихо умрет, либо так же тихо станет стандартом де-факто, но ни в 1 сценарии он не станет стандартом только потому что пользователей активно убеждают.
                                                                                        Действительно — активное убеждение не может быть единственным фактором. Очевидно что будут применены и другие.
                                                                                          0
                                                                                          Микрософт иногда страдает множественными личностями которые противоречат друг другу.
                                                                                          Вот поэтому я и говорю о том что евангелисты раста не ведут себя как инженеры, а ведут себя как рекламщики-продажники
                                                                                          While researching Rust, we found some issues that gave and continue to give us pause. Some of these concerns include how to regulate the usage of the “unsafe” superset of Rust at scale, lack of first-class interoperability with C++, and interoperability with existing Microsoft tooling. We’ll be blogging about many of these in the future as they do pose challenges for adoption at the scale of Microsoft, and we want to involve the Rust and wider software communities in helping us find solutions that work for everyone.


                                                                                          msrc-blog.microsoft.com/2019/07/22/why-rust-for-safe-systems-programming

                                                                                          Это было меньше года назад, не думаю что вдруг все описанные проблемы исчезли.
                                                                                            0
                                                                                            Вы не поверите, StackOverflow тоже похоже продались и ведут себя как продажники, может даже за процент, увы — это мир чистогана и «великой руки рынка, т.е. жиза».
                                                                                            stackoverflow.blog/2020/06/05/why-the-developers-who-use-rust-love-it-so-much

                                                                                            While some languages just add polish and ease to existing concepts, several users feel that Rust is actually doing new things with a programming language. And it’s not doing new things just to be showy; they feel these design choices solve hard problems with modern programming.
                                                                                              +4
                                                                                              Эта статья классический пример паблик-релэйшеншипс, а вы уже явно переходите в агрессивный стиль общения, который сообществу раст и ставится в вину. В погоне за популярностью в ход идут любые методы.
                                                                                              Поймите, эта технология может стать мэйнстримом, но будет это через годы и годы, если вообще будет. Те войны что ведете вы сейчас вообще бессмысленны.
                                                                                              Мы технари, хотим фактов, открытости и без передергивания, пожалуйста если вы один из нас — уважайте это.
                                                                                                0
                                                                                                Я тоже не вижу у вас инженерного подхода… говорить о том, чего не удалось лично прослушать в видео. Извините — мне тоже надоело, так что это взаимно. :)
                                                                                                Статья написана по видео? В нем все высказано…
                                                                                                  +1
                                                                                                  Еще ранее меня спросили — какие материалы, я даже вступать в эту дискуссию не хочу, потому что нужно потратить месяцы и годы своей жизни, чтоб понять — с тобой не были честны, я уже это время потратил.
                                                                                                  И вот сегодня я потратил еще 44 минуты своей жизни на очередной пиар.
                                                                                                  В этом видео (ОТ ИНЖЕНЕРА) единственные цифры это сколько денег стоит то и то и красивые графики которые можно рисовать пачками при продаже чего угодно нового, будь то процессор или машина, убеждая наивных покупателей почему им стоит потратить свои деньги.
                                                                                                  Расчет Раст сообщества прост — пока он сообразит у него уже весь тулчейн на нем, уже часть кода переписано и жалко все это бросать и вот новый боец в строю.
                                                                                                  Вы апеллируете к видео — я его посмотрел, это очередная рекламная брошюра занимающая 44 минуты!!! Карл, 44 минуты рекламы!
                                                                                                  Я больше ни 1 материала в своей жизни по расту не прочитаю, вот никогда. Когда станет стандартом де факто — тогда и приходите. До тех пор ни секунды своего времени.
                                                                                                    +4
                                                                                                    Я больше ни 1 материала в своей жизни по расту не прочитаю, вот никогда. Когда станет стандартом де факто — тогда и приходите. До тех пор ни секунды своего времени.
                                                                                                    Знаете вы мне напоминаете одного моего знакомого — бывшего Delphi-программиста. Он вот так же выступал, когда в конце прошлого века начала «активно насаждаться» Java (а до того — C++). Так и остался со своим Pascal (а потом, соответственно — Delphi).

                                                                                                    Когда он обратился ко мне лет 5 назад за советом «что теперь-то делать, когда его знания Delphi 7 больше не ценят»… я ответил, что, как бы, решать нужно было в 90е годы, в крайнем случае в нулевые… а сейчас — поезд ушёл.

                                                                                                    Он страшно на меня за что-то обиделся… до сих пор не знаю за что. Программировать он, насколько я знаю, бросил, сейчас на рынке чем-то торгует… но причём тут я? Я, что ли, заставлял его «вставать в позу» и отказываться от предложений работы на Java или C++ (когда ему ещё предлагали).

                                                                                                    Да, Rust дошёл до той стадии, когда важны (и нужны) не только технические статьи и видео, но и вот такие вот тоже.

                                                                                                    Потому что 90% программистов вообще пофигу на чём и как программировать — они не умеют программировать ни на каком. Но и те 10%, кому не всё равно, и тот 1%, который реально крутые вещи создают — они оттуда же вырастают.

                                                                                                    Расчет Раст сообщества прост — пока он сообразит у него уже весь тулчейн на нем, уже часть кода переписано и жалко все это бросать и вот новый боец в строю.
                                                                                                    Только это не «расчет Раст сообщества» — все популярные языки становятся популярными по этой вот схеме. Техническое совершенство вас в Top10 не выведет. Можете у фанатов Haskell спросить…
                                                                                                      +4

                                                                                                      Чаще всего языки через какую то нишу выстреливают, вот как пример котлин и андроид или свифт и ios.
                                                                                                      Да даже python и data science.


                                                                                                      Когда он обратился ко мне лет 5 назад за советом «что теперь-то делать, когда его знания Delphi 7 больше не ценят»… я ответил, что, как бы, решать нужно было в 90е годы, в крайнем случае в нулевые… а сейчас — поезд ушёл.

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

                                                                                                        +2
                                                                                                        Просто он не захотел ни в какой поезд садиться.
                                                                                                        Дык это и есть типичная проблема с людьми, требующими «инженерной честности»: они, как правило, способны понять что новое — это не сильно переделанное старое, но вот понять что этого вполне может быть достаточно для вытеснения и замены — почему-то неспособны.

                                                                                                        Ну вот почему «столбовая линия» ALGOL 58 ⇒ ALGOL 60 ⇒ ALGOL 60 ⇒ ALGOL W Pascal ⇒ Modula-2 ⇒ Modula-3 ⇒ Operon (бывшая весьма популярной в 60е-70е и даже в 80е годы) вдруг «иссхола» и оказалась вытеснена «внебрачным потомком» того же ALGOL, изменившися почти до неузнаваемости и его имитаторов (C/C++/Java/PHP)?

                                                                                                        Там же нет ничего вот принципиально, радикально нового!
                                                                                                          0

                                                                                                          Так ведь мог бы уйти в сишники, куда уж честнее то.

                                                                                                            0
                                                                                                            Как я понял C и C++ насаждали так же агрессиивно в конце 80х — начале 90х, как в конце оных же насаждали Java.

                                                                                                            Так что если исходить из позиции «мне говорят неправду, потому я никогда на этом языке ничего писать не буду» он тоже «некошерен».
                                                                                                        –1
                                                                                                        Т.е. теперь в ход пошел страх «а в будущем вы будете не удел» :) Очень мило, правда, никакого сарказма и иронии.
                                                                                                        Когда за плечами уже много всяких технологий, уже видел как одни поднимались, другие умирали — не очень страшно. И да, когда то тоже была делфи, потом были другие языки, это всего лишь технологии.
                                                                                                        Прочитайте внимательно мои комментарии — я уже изучил технологию, разочаровался. И да, меня не пугает изучение нового даже если я проморгал и это мэйнстрим :) За всеми белками не угонишься.
                                                                                                          +5
                                                                                                          Прочитайте внимательно мои комментарии — я уже изучил технологию, разочаровался.
                                                                                                          Я больше ни 1 материала в своей жизни по расту не прочитаю, вот никогда.

                                                                                                          Я, наверное, вас не так понял, но зачем вам тогда читать материалы по расту, если вы его уже изучили?