Кризис при продвижении языка программирования Rust в ядро Linux

По своему небольшому опыту использования, я тоже заметил что gcc analyzer лучше работает, и не дает ложных срабатываний в отличие от clang-tidy.

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

Скорее всего есть некая #pragma для отключения предупреждения на конкретной строке.

В Rust вся система типов, весь язык сделан так, что ты эту ошибку без unsafe не допустишь никак.

Ценой того что придется помечать всякие lifetime и пытаться любую систему построить на его ограничениях. Я лично хотел бы запустить gcc -fanalyzer, и пускай он сам ищет проблемы, он же компьютер, а не что бы я все расставлял вручную, и при любом изменении все переделывал.

Например твои примеры легко и gcc и clang находят, выше есть моя ссылка на godbolt.

То, что ты показываешь - это уже не C. Это тулинг вокруг C.

И, да, все эти valgrind-ы и линтеры это следствие недостаточной строгости C.

Мне кажется, тут дело не в строгости а в легаси. Ведь компилятор Си всегда разрабатывался по принципу «лишь бы не поломать тонну старого кода». По этому, по дефолту компилятор многое пропускает. Вот по этому, развитие Си шло черепашьими шагами, в то время как тулинг реализовал практически все что душе угодно (о чем ты упомянул).

Естественно, любой новый «инструмент» создается с учетом ошибок прошлого. Но в то же время, новый инструмент навязывает кучу вещей, которые, в том же системном программировании избыточны. По этому, иногда проще взять что-то до ужаса простое и реализовать ровно то что тебе нужно обмазавшись тулингом, нежели брать новое монстрообратное и использовать лишь 5% его возможностей. Инструмент нужно выбирать под задачу, а не наоборот. ИМХО, ниша раста – прикладнуха по типу браузера, где его потенциал может раскрыться на максимум. А совать его в системщину, ИМХО, глупость. Очевидно же, что любые встроенные проверки раста не бесплатны и пользователь будет оплачивать их тактами своего процессора, которые можно было бы пустить на что-то более нужное. А избавиться от них нельзя, так как смысл использования его тогда теряется.

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

Естественно, любой новый «инструмент» создается с учетом ошибок прошлого.

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

Еще сюда добавляется слепая уверенность в том что текущее лучше старого. Вот есть ужасный нечитаемый m4, а есть хайповый код на Rust:

macro_rules! forward_to_deserialize_any_method {
    ($func:ident<$l:tt, $v:ident>($($arg:ident : $ty:ty),*)) => {
        fn $func<$v>(self, $($arg: $ty,)* visitor: $v) -> 
        $crate::__private::Result<$v::Value, <Self as $crate::de::Deserializer<$l>>::Error>
        where $v: $crate::de::Visitor<$l>, {$(let _ = $arg;)*
            self.deserialize_any(visitor)}};}

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

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

ИМХО, ниша раста – прикладнуха по типу браузера, где его потенциал может раскрыться на максимум

Кстати о системном применении, Rust и его библиотека так спроектированы, что нехватка памяти не обрабатывается, а просто среда сразу паникует (exit(1)), панику можно перехватить, но стек раскручивается без вызова деструкторов, что лишь добавляет проблем.

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

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

а есть хайповый код на Rust:

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

Ну да, потому что они всё ядро засунули в один юзерспейсный процесс. Потому и не проседает. Это фактически вариант паравиртуализации, как в Xen было.

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

Нагуглил замеры переключений ядра 7-летней давности там насчитали 2.2 микросекунды, округлим до 2.5us. Это дает нам 400 000 переключений в секунду на одно ядро.

1 000 переключений будет съедать примерно 0.25% одного ядра процессора.

20 000 переключений будет съедать примерно 5% одного ядра процессора. А если размазать это по 4-8 ядрам вообще ниочем получается.

Так что на данный момент я бы не был так уверен что на современном ПК переключение контекста будет занимать больше единиц процентов для микроядра. Если где-то неправильно посчитал буду рад если укажут на ошибку.

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

Элегантно критикую Rust, мое ожидание реакции фанатов Rust:

Спасибо мистер МОРКОВКА за то что раскрыли нам глаза! Впредь будем критически смотреть на наш язык, и не допустим повторения ошибок прошлого!

Реальность

Слыш хомячек, может тебе С++ stl показать? Или расчлененку? Наш язык конечно нечитаемое уродство, но мы и страшнее вещи можем создать, усек?

растчленёнку

Да

Элегантно критикую Rust

Это молодёжь так сейчас называет жирный наброс? Проблема критиканов в том, что они даже доку по языку не читали, прям как те пионеры с карикатуры.

Поищи по ЛОРу где в срачах народ реальные проблемы Rust приводил, а не вот это вот твоё «я ниасилил доку».

Кстати, с регулярками у тебя как, стул не горит?

Это молодёжь так сейчас называет жирный наброс?

Никаких набросов не было.

Кстати, с регулярками у тебя как, стул не горит?

А ты все продолжаешь. Знаешь какой язык имеет регулярки, одновременно с репутацией нечитаемого? Это не Rust, ведь там нету регулярных выражений в std.

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

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

Да и что мы все о макросах, лучше настоящие функции!

fn try_extract_error_from_region_constraints<'a, 'tcx>(
    infcx: &'a InferCtxt<'tcx>,
    generic_param_scope: LocalDefId,
    placeholder_region: ty::Region<'tcx>,
    error_region: Option<ty::Region<'tcx>>,
    region_constraints: &RegionConstraintData<'tcx>,
    mut region_var_origin: impl FnMut(RegionVid) -> RegionVariableOrigin,
    mut universe_of_region: impl FnMut(RegionVid) -> UniverseIndex,
) -> Option<Diag<'a>> {
    let placeholder_universe = match placeholder_region.kind() {
        ty::RePlaceholder(p) => p.universe,
        ty::ReVar(vid) => universe_of_region(vid),
        _ => ty::UniverseIndex::ROOT,
    };
    let matches =
        |a_region: Region<'tcx>, b_region: Region<'tcx>| match (a_region.kind(), b_region.kind()) {
            (RePlaceholder(a_p), RePlaceholder(b_p)) => a_p.bound == b_p.bound,
            _ => a_region == b_region,
        };
}

Никаких набросов не было.

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

А ты все продолжаешь.

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

А тут что тебе непонятно? Коньструкция let ... = match ...?

Так пишут лучшие из лучших, как пишет компьюнити лучше мне не знать.

А точно лучшие?

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

Ну так и brainfuck легко любой прочтет, там всего пару операторов. Ну и любую регулярку, даже такую:

(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
)+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:
\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(
?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ 
\t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\0
31]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\
](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+
(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:
(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)
?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\
r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[
 \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)
?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t]
)*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[
 \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*
)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t]
)+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)
*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+
|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r
\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:
\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t
]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031
]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](
?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?
:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?
:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)|(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?
:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?
[ \t]))*"(?:(?:\r\n)?[ \t])*)*:(?:(?:\r\n)?[ \t])*(?:(?:(?:[^()<>@,;:\\".\[\] 
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|
\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>
@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"
(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t]
)*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?
:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[
\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:[^()<>@,;:\\".\[\] \000-
\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(
?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)?[ \t])*(?:@(?:[^()<>@,;
:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([
^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\"
.\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\
]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\
[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\
r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] 
\000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]
|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?(?:[^()<>@,;:\\".\[\] \0
00-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\
.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,
;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|"(?
:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*))*@(?:(?:\r\n)?[ \t])*
(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".
\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t])*(?:[
^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\]
]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(?:\r\n)?[ \t])*)(?:,\s*(
?:(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(
?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[
\["()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t
])*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t
])+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?
:\.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|
\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*|(?:
[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".\[\
]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)*\<(?:(?:\r\n)
?[ \t])*(?:@(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["
()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)
?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>
@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*(?:,@(?:(?:\r\n)?[
 \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,
;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\.(?:(?:\r\n)?[ \t]
)*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\
".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*)*:(?:(?:\r\n)?[ \t])*)?
(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\["()<>@,;:\\".
\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])*)(?:\.(?:(?:
\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z|(?=[\[
"()<>@,;:\\".\[\]]))|"(?:[^\"\r\\]|\\.|(?:(?:\r\n)?[ \t]))*"(?:(?:\r\n)?[ \t])
*))*@(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])
+|\Z|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*)(?:\
.(?:(?:\r\n)?[ \t])*(?:[^()<>@,;:\\".\[\] \000-\031]+(?:(?:(?:\r\n)?[ \t])+|\Z
|(?=[\["()<>@,;:\\".\[\]]))|\[([^\[\]\r\\]|\\.)*\](?:(?:\r\n)?[ \t])*))*\>(?:(
?:\r\n)?[ \t])*))*)?;\s*) 

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

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

Почему то в С не наворачивают адок на макросах в каждом втором проекте.

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

Хм. Вот форкнули бы они Линукс и портировали систему за системой на Раст, показали бы всему миру как надо. Заодно от легасей полностью избавиться. Интересно как изменится размер портированных исходников.

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

Надеюсь, это всё приведёт к тому, что создадут ОС на расте с линуксовым апи.

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

Он понятный, просто стилистически всратый. Этим почему-то страдают компиляторы, libc и прочие странные люди.

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

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

Он понятный, просто стилистически всратый. Этим почему-то страдают компиляторы, libc и прочие странные люди.

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

Этим почему-то страдают компиляторы, libc и прочие странные люди.

Это почти любой проект на Rust, просто напомню что сишного препроцессора там нету, любой макрос вида #define SUM(A, B) A+B там имеет подобный вид.

и опять же, показать всем как надо делать?

ты што, надо же победить древнее сишечное зло в его логове причом

Покажи одну строку, которую ты не понял при прочтении кода.

Покажи сначала где я писал «я не понял этот код на Rust». Я сравнивал код с m4, который легко перепутать с Rust.

divert(`-1')
define(`forloop', `ifelse(eval(`($2) <= ($3)'), `1',
  `pushdef(`$1')_$0(`$1', eval(`$2'),
    eval(`$3'), `$4')popdef(`$1')')')
define(`_forloop',
  `define(`$1', `$2')$4`'ifelse(`$2', `$3', `',
    `$0(`$1', incr(`$2'), `$3', `$4')')')
divert`'dnl

Вот тебе что то непонятно? Язык то довольно прост.

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

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

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

В нем нет странного. В нем нет магии. В нем просто напихали в одну функцию много переменных и отформатировали всрато.

Это почти любой проект на Rust, просто напомню что сишного препроцессора там нету, любой макрос вида #define SUM(A, B) A+B там имеет подобный вид.

Это не так. Потому что для сишных макросов вида SUM(A, B) в раст просто функцию напишут.

Я не понимаю зачем. Вот есть некоторый контингент людей разрабатывающей линукс на сях. Раста они не знают и не смогут работать на нём эффективно. Он даже спецов ставит в тупик. Значит придётся ВСЁ написать самим растопропихивателям. Но если переписать за них всё на расте, то эти люди тут же станут ненужными. Надо будет искать новых, растоманов, или поддерживать свмому. Что произойдёт в итоге? Это, считай, будет новый проект с новыми людьми и новыми идеями. Зачем ломать существующий? Я очень понимаю людей не желающих принимать его. Раст им ничего не даст кроме раздора, переделок ради переделок и проблем

Зачем? У меня он стоит из репозиториев.

Затем, что этим ты привязан к маинтейнерам своего дистрибутива, которые могут: [1] выпустить обновление сильно позже, [2] не выпустить обновление вообще, потому что дистрибутив не роллинг или им просто лень, [3] собрать его не так, как автор и привнести свои баги. Вот в Федоре, раньше, Git после релиза дистрибутивы уже не обновлялся, кроме исправлений безопасности. Сейчас это поменялось, но всё равно не хочется зависеть от желаний маинтейнеров. Чёрт его знает что им завтра придёт в голову.

Зачем ломать существующий?

весь мир наСИ-лья мы разрушим
до основанья
а затем (может быть)

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

план Б - привести невесту прямо в родительскую хазу

В нем нет странного. В нем нет магии. В нем просто напихали в одну функцию много переменных и отформатировали всрато.

Ну давай сократим макрос

macro_rules! forward {
  ($func:ident<
    $l:tt, $v:ident>($($arg:ident : $ty:ty),*)
  ) => {}
}

Пропали ли $<A*%R*#? Нет, на месте.

fn try_extract<'a, 'tcx>(
  infcx: &'a InferCtxt<'tcx>,
  mut region_var_origin: impl FnMut(RegionVid) -> RegionVariableOrigin) -> Option<Diag<'a>>
{
  let matches =
        |a_region: Region<'tcx>, b_region: Region<'tcx>| match (a_region.kind(), b_region.kind()) {
            (RePlaceholder(a_p), RePlaceholder(b_p)) => a_p.bound == b_p.bound,
            _ => a_region == b_region,
        };
}

Лучше? Мне лично так не кажется.

Это не так. Потому что для сишных макросов вида SUM(A, B) в раст просто функцию напишут.

Ну давай посмотрим, напиши ка:

#define SUM(A, B) (sizeof(A) + sizeof(B))

весь мир наСИ-лья мы разрушим

до основанья

а затем (может быть)

Мы своооой, мы новый мир построоооим, кто был ничем тот стал никеееем...

ниаСИливают

Похоже ты нашёл корень проблемы! Я думаю надо начать с реформы человеческого языка. Языков. Всех. Потому что нас с детства окружают всякие «Си» и «Плюсы» и даже «Питоны». На всех, практически языках. А Раст ассоциируется только с нехорошим и только у англоязычных. Поэтому сопротивляются. Надо этим, коковцам, как их там, дать задачу.

Затем, что этим ты привязан к маинтейнерам своего дистрибутива, которые могут: [1] выпустить обновление сильно позже, [2] не выпустить обновление вообще, потому что дистрибутив не роллинг или им просто лень, [3] собрать его не так, как автор и привнести свои баги.

У меня рач, я уже говорил? Здесь нет этой проблемы.

Вот в Федоре, раньше, Git после релиза дистрибутивы уже не обновлялся, кроме исправлений безопасности. Сейчас это поменялось, но всё равно не хочется зависеть от желаний маинтейнеров. Чёрт его знает что им завтра придёт в голову.

Это тревожность.

Я повторно взял из своего старого комментария, это serde_json. Ну давай что нибудь другое посмотрим, некий пакет legion:

impl<Iter, $( $ty: Component ),*> IntoComponentSource for Aos<($( $ty, )*), Iter>
    where
  Iter: Iterator<Item = ($( $ty, )*)>,
  Aos<($( $ty, )*), Iter>: ComponentSource
{
  type Source = Self;
  fn into(self) -> Self::Source { self }
}

#[cfg(feature = "parallel")]
impl<'a, F: Fetch> rayon::iter::IntoParallelIterator for ChunkView<'a, F> {
    type Iter = crate::internals::iter::indexed::par_iter::Par<<F as IntoIndexableIter>::IntoIter>;
    type Item = <<F as IntoIndexableIter>::IntoIter as crate::internals::iter::indexed::TrustedRandomAccess>::Item;
    fn into_par_iter(self) -> Self::Iter {
        use crate::internals::iter::indexed::par_iter::Par;
        Par::new(self.fetch.into_indexable_iter())
    }
}

У меня не работает

sum(i32, i32);
    ^^^ not a value

Хотя это вроде норма, в Rust оказалось нету sizeof, сейчас тогда другой пример придумаю.

Хех.

fn sum(comptime T1: type, comptime T2: type) usize {
    return @sizeOf(T1) + @sizeOf(T2);
}

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

#define or_return(expr) if (!(expr)) return -1;

ты испугался длинных идентификаторов что ли?

Нет, вот я сократил до одной буквы, выглядит так же ужасно:

#[cfg(feature = "parallel")]
impl<'a, F: F> r::i::I for C<'a, F> {
    type I = c::i::i::i::p::P<<F as I>::I>;
    type I = <<F as I>::I as c::i::i::i::T>::I;
    fn i(self) -> Self::I {
        use c::i::i::i::p::P;
        Par::new(self.fetch.into_indexable_iter())
    }
}

impl<' ,  :  >  :: ::  for  <' ,  > {
    type   =  :: :: :: :: :: <<  as  >:: >;
    type   = <<  as  >::  as  :: :: :: :: >:: ;
    fn  (self) -> Self::  {
        use  :: :: :: :: :: ;
         :: (self. . ())
    }
}

У меня рач, я уже говорил? Здесь нет этой проблемы.

Там другие проблемы. Роллинг дистрибутивы подходят далеко не всем. В частности у меня от Арча довольно негативные впечатления.

Это тревожность.

Это реальность.

Нагуглил что обычно в секунду ядро не делает больше 1 000 переключений контекста,

Ты не то нагуглил. Это таймер. И он может быть разным, зависит от настроек ядра.

~  zcat /proc/config.gz | grep CONFIG_HZ
# CONFIG_HZ_PERIODIC is not set
# CONFIG_HZ_100 is not set
CONFIG_HZ_250=y
# CONFIG_HZ_300 is not set
# CONFIG_HZ_500 is not set
# CONFIG_HZ_1000 is not set
CONFIG_HZ=250

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

будем исходить из того что микроядро увеличит это значение в 20 раз.

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

И тут добрался этот трамп. Консерваторы наносят ответный удар

Ты не то нагуглил. Это таймер. И он может быть разным, зависит от настроек ядра.

Вроде то, там было среднее 400 переключений. А больше 1 000 это уже что-то не то с системой.

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

Всё равно думаю что можно решить.

Тут проблема в том, что для того чтоб написать полностью рабочую ОС нужно дохрена времени потратить. Взять к примеру FreeBSD, система хорошая но отношение к ней как к экзотике которую используют для NAS или на редких серверах. Даже сложно представить сколько нужно затратить человеко-часов чтоб сделать микроядерную ОС которая бы приблизилась хотя-бы к FreeBSD по возможностям.

Вроде то, там было среднее 400 переключений. А больше 1 000 это уже что-то не то с системой.

Херли? Ты послал 1000 пакетов (~1.5 мегабайта) за секунду через send(), вот у тебя 1000 сисколлов и 1000 переключений.

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

Тут проблема в том, что для того чтоб написать полностью рабочую ОС нужно дохрена времени потратить.

Капитан!

Взять к примеру FreeBSD, система хорошая но отношение к ней как к экзотике которую используют для NAS или на редких серверах.

FreeBSD – очень дерьмовая система, застрявшая в 90х. На сегодняшний день, FreeBSD – это такой недолялекс под BSD лицензией и без драйверов, но при этом с гей-повесточкой и консультантами по разнообразию (не шучу).

Даже сложно представить сколько нужно затратить человеко-часов чтоб сделать микроядерную ОС которая бы приблизилась хотя-бы к FreeBSD по возможностям.

Гораздо меньше, чем ты думаешь. Благо, драйвера можно взять из той же FreeBSD.

Херли? Ты послал 1000 пакетов (~1.5 мегабайта) за секунду через send(), вот у тебя 1000 сисколлов и 1000 переключений.

А если слать по 64КБ, то будет 24 вызова. А можно еще вызовы в очередь складывать, да кучу всего можно придумать как уменьшить количество вызовов.

Херли? Ты послал 1000 пакетов (~1.5 мегабайта) за секунду через send(), вот у тебя 1000 сисколлов и 1000 переключений.

А если слать по 64КБ, то будет 24 вызова. А можно еще вызовы в очередь складывать, да кучу всего можно придумать как уменьшить количество вызовов.

Да, я об этом и пишу.

Тем не менее, 1000 сисколов в секунду – это не то чтобы что-то страшное.

Хотя это вроде норма, в Rust оказалось нету sizeof, сейчас тогда другой пример придумаю.

Ты переменную или тип суешь?

Там другие проблемы. Роллинг дистрибутивы подходят далеко не всем. В частности у меня от Арча довольно негативные впечатления.

Greg KH может и ты можешь.

Это реальность.

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

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