В чем смысл Rust?

у вас разрешающее ваш тезис множество пусто

ну или вы единственный её член ( если сишните)

Ни один истинный шотландец (англ. No true Scotsman), игнорирование контрпримера или апелляция к истинности — неформальная логическая уловка, попытка ad hoc сохранить в силе необоснованное утверждение[1]. Когда встречается контрпример, опровергающий универсальное заявление, то вместо опровержения контрпримера или отказа от исходного универсального заявления, эта логическая уловка изменяет субъект утверждения таким образом, чтобы исключить этот специфический случай или другие подобные с помощью риторики, без ссылок на какие-либо объективные правила.

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

Можно список «нормальных C-программистов» по именам? Живые есть среди них?

Я всё понял. С не случайно появился одновременно с модой на дзен-буддизм в США. Это не язык программирования, как мы ошибочно предполагали, а дзен-практика. Путём непрестанного разглядывания указателей адепт должен осознать иллюзорность всего сущного, просветлиться, перестать программировать, уехать в деревню смотреть как трава растёт, овцы едят траву, а изображение в зеркале медленно стареет. Так становятся настоящими сишниками.

Не знаю как насчёт дзена, но большую роль играет, как мне кажется, ощущение причастности к крутым программистам, хакерам, к низкоуровневым (а потому несомненно крутым) проектам: «Мы, сишники, ядра пишем, драйверы и прошивки!!!1». Писать ядро, конечно необязательно, главное разобраться, что такое указатель, и написать пару программ по сотне строчек, которые чудом не сегфолтятся на корректных входных данных, и вот ты уже причастился.

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

Ну так всё правильно.

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

Какой язык и компилятор такое позволит сделать?

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

Даже гугловский чатгпт это умеет:

#include <stdio.h>

#define SIZE 10

// Макрос для проверки границ массива
#define SAFE_ARRAY_WRITE(arr, index, value, size) \
    if ((index) >= 0 && (index) < (size)) { \
        (arr)[index] = (value); \
        printf("Успешно записано arr[%d] = %d\n", index, value); \
    } else { \
        printf("Ошибка: Индекс %d вне диапазона [0, %d)\n", index, size); \
    }

int main() {
    int myArray[SIZE];

    // Корректная запись
    SAFE_ARRAY_WRITE(myArray, 5, 55, SIZE);

    // Некорректная запись (индекс за пределами)
    SAFE_ARRAY_WRITE(myArray, 10, 99, SIZE);

    return 0;
}

В общем, Си – это круто!

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

Это работает не только с массивами фиксированной длины: В чем смысл Rust? (комментарий)

там был Шумпетер? с less is more (именно так) https://en.wikipedia.org/wiki/Small_Is_Beautiful#:~:text=HB171 .S384 1989-,Sm...

скорее кризис вокруг 1970+-3 с римским клубом пределами роста и скрытия безработицы через homebrew

ваще журнал Byte c 1975 по япи-времена очень информативен в части трансформации

чтобы мочь записывать за пределы переменных на стеке

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

Да. Просто когда проверка нужна, то ты ее добавляешь, и всё.

Серьезные программы на Си никогда не пишутся с прямым доступом к элементам массивов в произвольном месте программы. Всё давно «завернуто» в соответствующие библиотеки и «объекты», чтобы программист был сосредоточен на бизнес логике, а не на вот этих всех нюансах.

Из моей практики, самые сложные ошибки – логические и смысловые («соленое» «складывают» с «красным»), а не технические (выход за границу массива или переменной).

unC0Rr, примите пожалуйста этот ответ и на ваше замечание.

Мы, сишники, ядра пишем, драйверы и прошивки!!!1

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

Линуса rust-is-here-to-stay Торвальдса будем выписывать из настоящих сишников?

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

самые сложные ошибки – логические и смысловые («соленое» «складывают» с «красным»)

Rust предоставляет средство, паттерн NewType, для борьбы с такими ошибками.

Дедушка старенький, а паяльник жгучий.

OpenSSL пишут несерьёзные программисты на Си (heartbleed), ядро линукса пишут несерьёзные программисты на Си…

https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/commit/?id...

https://nvd.nist.gov/vuln/detail/cve-2022-0492

Си великем тем, что это базовый язык, который без всего лишнего просто на любом UNIX’е собирается, а работает на любой роутере хоть с 16 мегабайтами оперативки. А вот Rust как раз гораздо сложнее Си, как и хаскель, как и любоя функциональщина. Лет 20 назад все писали на Си и не жаловались, да даже 10 лет назад ни у кого не было таких мыслей о Си, как у тебя.

База!

Лайк не ставлю, так как эмодзи — это растоманское хипстерство.

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

После выгона русских из ядра по причине национальности Линуса никто всерьез не воспринимает.

Лет 20 назад все писали на Си и не жаловались

Ага, конечно. Даже в 80-х жаловались. Иначе бы цпп не пришлось изобретать.

да даже 10 лет назад ни у кого не было таких мыслей о Си

10 лет назад такие мысли были как минимум у меня, потому что хаскель я распробовал 20 лет назад, а 10 лет назад уже изучал раст.

Иначе бы цпп не пришлось изобретать.

В 80-х C++ был Си с классами, даже мерзкого STL в нем тогда не было.

10 лет назад такие мысли были как минимум у меня

Меня интересуешь не только ты.

хаскель я распробовал 20 лет назад

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

ибо Haskell крайне сложен

ээээ?

если понимание сложнее зазубривания только

как раз таки ортогональный язык обычно проще очередного «pl/i» понятного всем и полное описание языка(ну и его батареек) которого требует либо зубрилу либо заведомое плавание в нюансах

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

Вы пишете про технические ошибки - не совпадение «унаследованных» типов у переменных в коде.

Логические и смысловые, это, например:

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

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

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

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

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

Я пишу на си не потому что мне так хочется, а потому что у меня такая работа, embedded, делать умными различные изделия с микропроцессорами уровня от микроконтроллеров типа STM32 и AT Tiny до x86. И везде переиспользуются различные части программного кода.

Haskell крайне сложен

Ещё один язык, про который ты ничего не знаешь, но берёшься рассуждать.

Ряды настоящих сишников жидеют.

Я тоже не знаю зачем нужен раст, если и на Си нормально. А еще лучше С++.

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

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

Зачем нужны другие языки я не знаю.

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

Так Rust позволяет то же самое, но без лютого треша, которым является C++. В каком-то смысле это что-то типа «каким должен был бы быть C++, если бы его проектировали, а не лепили от балды костылями и подпорками в течение десятилетий».

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

Например, люди, пришедшие в маунтин-байк (МТВ) из BMX показывают лучшие результаты, чем кто сходу учился на МТВ. Почему? А потому что трюки, баланс, координация, чувство своего тела и велосипеда.

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

Я вот трековый велогонщик. Казалось бы трек – это же только мощность. Какие тут трюки? Но у нас тоже есть упражнения на технику владения велосипедом. И на МТВ я иногда катаюсь.

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

Так Rust позволяет то же самое, но без лютого треша, которым является C++.

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

Треш мы генерируем сами. Ну а по-другому кто тебе его генерирует? ИИ? Или студента приглашаешь? Как напишешь так и будет. Хочешь без треша – пиши без треша. С++ тут не причем.

И да, хотелось бы понять, что является трешом. Ну чтобы понимать о чем мы.

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

Как напишешь так и будет.

Если пишешь один.

Хочешь без треша – пиши без треша.

В чужом коде не получится.

И да, хотелось бы понять, что является трешом. Ну чтобы понимать о чем мы.

C++ является нагромождением всего, что только можно, понадёрганным отовсюду, откуда только можно. При этом сохраняя UB и т.п. То есть, по сути своей, это свалка. Чтобы изучить C++, требуется реально не один десяток лет. Для Rust хватит месяца-другого. Это если под изучением понимать именно знание языка, а не какого-то его небольшого подмножества, и не умение просто написать на нём код. Знание языка подразумевает способность, прочитав любой код, написанный человеком любой степени криворукости или упоротовсти, понять, как именно он отработает.

Да, на C++ можно относительно безболезненно писать, если запретить себе половину того, что там есть, выбрав некое «адекватное» подмножество. И можно даже горя не знать с этим, наврное. В том числе если это прописать в документ, обязательный для следования всеми членами коллектива, в котором ты занимаешься разработкой. Но когда сталкиваешься с кодом, написанным хрен знает когда по упорке на волне хайпа приматывания к C++ скотчем очередной фичи, становится сложнее. Всюду мины в виде UB и прочего непотребства.

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

Эти две проблемы отсутствуют в Rust. Да, это не идеальный язык, и в нём есть свои минусы, как объективные, так и чисто в виде вкусовщины. Но если сравнивать с тихим ужасом, которым является C++, Rust это то, «как надо было».

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

И Rust тоже. Вообще-то Zero Cost Abstractions — один из основных принципов Rust.

P.S. Мне не очень комфортно в как бы навязываемой мне роли защитника Rust, если честно. Я не являюсь его фанатом и считаю, что в целом чем больше языков, тем лучше. Я скорее C++-хейтер, нежели фанат раста или чего-то ещё.

C++ современный, где уже от сишки мало что осталось.

В том и проблема, что осталось. И ещё куча сверху налеплена.

Не знаю, я вот открыл раст в примерах, статью на хабре. И вижу, что компилятор запрещает некоторое поведение, которое считает опасным. Блин, ну это розовые сопли какие-то. И какая же это нулевая цена?

Не инициализированные переменные – о, ужас, нельзя, табу. Че воще за бред? А растеры знают, что запись лишнего значения в переменную – тоже нагрузка? В С++ статический анализатор тоже орет, когда ему кажется, что переменная не проинициализирована в одном из ответвлений кода. Дак она там и не нужна, в этом ответвлении она не используется. А там, где используется, там инициализирована. И незачем ее по сто раз для всех ответвлений инициализировать.

Присвоение целочисленной переменной булева значения – какой ужас, все, кошмар, компилироваться не буду. Да тьфу ты ёлки! Буду, не буду. Все – есть числа. Ну ладно, почти все. А то, что не все – то наборы чисел. И не надо тут выкобениваться.

Розовые сопли какие-то этот ваш раст. Что ты, деточка, жить воще опасно, можно умереть.

Растерам уже промыли мозг хорошо, что теперь это у них табу.

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

Для этого есть unsafe. И это плюс.

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

И какая же это нулевая цена?

Ты уверен, что понимаешь, о чём речь, когда говорится о нулевой цене?

блаблабла

Это уже философия, к обсуждаемому ранее не имеющая отношения. Тебя никто не заставляет использовать Rust и не отбирает Си — стреляй в ноги на здоровье хоть целый день, кто ж против. Ну или в unsafe пиши на расте то же самое — тоже никто слова не скажет… ну или может кто и скажет, конечно, смотря ещё как напишешь, но в любом случае хозяин барин. Того, что C++ является лютым трешем и мешаниной, это всё никак не отменяет. А о том, нужны ли все эти проверки хоть в компиляторе раста, хоть в статических анализаторах для сей или крестов — это ты с кем-нибудь другим поспорь, ладно? Как я писал выше, в роли адвоката раста мне неуютно, и я не нанимался.

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

Нюанс тут в том что одноколесный велосипед был без сидения (модель владения памяти) и тормозов (borrow checker), а новый двухколесный вариант имеет эти «еретические» нововведения. Вот и страдают атлеты на форумах, вздыхая о том что раньше было лучше. Ну и что что без сидения, нормально же катались, и по ухабам…

У нашего тренера есть такие тренировки без седла. Внатуре седло снимает и ты катаешься по треку стоя. Типа силу ног развивает, стато-динамические нагрузки. И координацию. Без седла сложнее балансировать на треке в виражах. А что до тормозов, то на трековом велике их и так нет. Там глухая передача. Как крутишь ногами, так и едешь, ничего лишнего. Все зависит только от тебя.

Крякс сказал с ним не спорить. Так что я сам с собой спорю…

В Rust Book, в 17 главе приводят: «Если язык должен иметь наследование, чтобы быть объектно‑ориентированным, то Rust таким не является. Здесь нет способа определить структуру, наследующую поля и реализации методов родительской структуры, без использования макроса»

— это пии-и-и-и…. Жалко, тут матом не ругаются, но нематных слов у меня на это не осталось. Одни эмоции.

Не инициализированные переменные – о, ужас, нельзя, табу.

Тоже самое в Go. И это правильно.

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

А потом код развивается дальше и человеки забывают доинициализировать ее в нужном месте…

У большинства в этой ветки сильное когнитивное искажение (и это нормально). Вы рассматриваете язык как инструмент для одного программиста пишущего проект уровня калькулятора.

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

Все на что вы ругаетесь является ответом индустрии на самые частые ошибки которые программисты совершают при СОВМЕСТНОЙ разработке. Как только вы это осознаете все встанет на свои места.

Go стал ответом на распространенные ошибки команд в асинхронщине, Rust стал ответом на распространенные ошибки команд в мультипроцессорщине.

Модель владения памяти в Rust - качественна и элегантна. Она основана на вложенных умных указателях (паре атомарных счетчиков у выделенной области памяти) и позволяет избежать большинство «тупых» ошибок при работе с памятью при совместной разработке.

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

В том-то и дело что С-программисты ездят сидя…

Здесь нет способа определить структуру, наследующую поля и реализации методов родительской структуры, без использования макроса

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

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

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

И вот для вторых людей ограничения конечно воспринимаются тяжело.

Может быть надо перестать брать на работу выпускников всяких курсов типа «войти в айти за 2 недели»?

С Rust’ом у меня есть негативный опыт взаимодействия, а про Haskell я слышал, что для него нужно минимум 120 IQ.

Что не так? Что наследование реализации – зло и его надо заменять на агрегирование, было написано в каждой первой книге по ООП. Все новые языки избавлены от этой архитектурной ловушки.

ООП надо запретить на государственном уровне.

для вторых людей ограничения конечно воспринимаются тяжело.

Надеюсь, речь про ограничения коммуникации при командной разработке, ограничения человеческой памяти и пределов внимания, а не ограничения вида «нельзя в переменную одного типа записать значение другого типа»?