Rust 1.55.0

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

https://www.opennet.ru/opennews/art.shtml?num=55675

Мне сама по себе концепция куба не понравилась: предпочитаю configuration as code, чем тыкать. Да и yed неплохой, но опять же предпочитаю в коде как-то выразить - dot или mermaid.

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

Разница принципиальна.

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

Я за всех утверждать не буду. Но проводил слепое тестирование на себе и на товарище. Оба 72 от 144 герца отличали чуть чаще, чем в 50%, т.е. действительно эффект едва заметен.

А чего нет?

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

Наверное ты не профессионал, вот и спотыкаешься.

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

Сложно - компилятор строгий слишком

Это для предотвращения ошибок. ИМХО, пускай лучше компилятор ругается, нежели пропускает дрянной код. Проблемой, вероятно, является тот факт, что компилятор медленный, нет аналога ccache.

даже когда пишешь небольшую программу с нуля постоянно о него спотыкаешься

Просто язык надо знать.

Из больших проектов — alacritty, Redox-OS.

Наверное ты не профессионал, вот и спотыкаешься.

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

ИМХО, пускай лучше компилятор ругается

Как-то он очень часто ругается, поэтому программировать на расте сложно и технически, и психологически.

Как-то он очень часто ругается

Лично я закалён статическими анализаторами для пхп.

поэтому программировать на расте сложно и технически

Нет, просто язык надо знать.

психологически

Никогда такого не замечал.

А ты хаскель изучал?

Речь про сборку OpenJDK?

Пересобрал ради интереса OpenJDK15 — на всё про всё максимум задействовано 4,3 ГБ (пик занятости под систему и все запущенные программы) и пять минут времени на компиляцию, три минуты на перепаковку архивов.

нет аналога ccache.

Есть, https://github.com/mozilla/sccache

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

Именно поэтому rust много лет в любимых языках по опросам, ибо целые классы ошибок устраняются до отладки.

Хм, думал, что оно сдохло.

Спасибо.

А ты хаскель изучал?

Неа, не приходилось.

Хм, думал, что оно сдохло.

Я не пользуюсь растом, просто помнил что аналог ccache для него есть.

Хотя, вот есть issue: https://github.com/mozilla/sccache/issues/1022

Так что может ты и прав, но там вроде форк готовится https://github.com/paritytech/cachepot

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

Сколько раз уже уволили?

• Никаких ЗАВИСИМОСТЕЙ нет

depLookup : DecEq t => {w : t} -> {f, g : t -> Type} -> DecEq (f w) =>
             (vs : Vect n (v : t ** (f v, g v))) -> f w ->
             Maybe (a : f w ** b : g w ** Elem (w ** (a, b)) vs)
depLookup [] item = **Nothing -- Not found**
depLookup ((n ** (key, val)) :: xs) item {w} with (decEq w n)
  -- if indices don't match then values can't tools match since they have different type
  depLookup ((n ** (key, val)) :: xs) item {w = w} | (No contra) =
    do (a ** b ** prf) <- depLookup xs item
       pure (a ** b ** There prf)
  depLookup ((n ** (key, val)) :: xs) item {w = n} | (Yes Refl) with (decEq key item)
    depLookup ((n ** (item, val)) :: xs) item {w = n} | (Yes Refl) | (Yes Refl) =
      Just (item ** val ** Here {x=(n ** (item, val))})
    depLookup ((n ** (key, val)) :: xs) item {w = n} | (Yes Refl) | (No contra) =
      -- Index match but values differ
      do (a ** b ** prf) <- depLookup xs item
         pure (a ** b ** There prf)

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

Ну, вот заблокируют вам доступ на crates.io и на rust-lang.org. Что будете делать тогда? Может быть, rust и защищает от технических ошибок, но разве он защитит вас от безумных людей?

А прецеденты есть с тем же языком Go и сервисом GitHub.

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

вот заблокируют

Что будете делать тогда?

Остановим котел в лютый мороз.

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

#[link(name="stream", kind="static-nobundle")]

Почём побочные эффекты для народа?

liftM :: (a -> b) -> (IO a -> IO b)
liftM f stream = do x <- stream
                    return (f x)

(>>=) :: IO a -> (a -> IO b) -> IO b
(ISO >>= ITO) stream =
   let (a, stream1) = ISO stream
       (b, stream2) = ITO a stream1
   in (b, stream2)

std::istream& operator>>(std::istream& is, Stream& obj)
{
    char8_t price;
    is.exceptions(std::ios::failbit | std::ios::badbit);
    is.clear(is.rdstate() & ~std::ios::failbit);  
    is.imbue(std::locale("de_DE.ISO-8859-15"));
    std::get_money(price, true);
    return is;
}

Есть DZigNim

Покажешь мне IDE написанную на Rust/CPP по функциональности аналогичную IDEA?

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

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

Ну, вот заблокируют вам доступ на crates.io и на rust-lang.org. Что будете делать тогда?

Ну, вот заблокируют вам доступ к бусту/Qt/abseil. Что будете делать тогда?

Для «параноиков» есть cargo vendor.

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

42 компании что-то пишут.

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

Зачем тогда спрашиваешь если во всем разобрался?

Во первых, это не дискуссия, а глупый вброс. Во вторых, аргументов против, как я понимаю, у тебя нет?

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

Лет через 10 или 20 модель распространения исходников через npm или cargo признают недостаточно надежной и, возможно, даже ошибочной и тупиковой. Здесь и на ЛОРе об этом постоянно пишут. Сегодняшний плюс превратится в огромный минус завтра. Нужно смотреть наперед.

С точки зрения безопасности и возможных технологических рисков, rust еще находится на зачаточном уровне. Язык безусловно один из самых красивых среди тех, что придумали люди. Даже код получается очень эффективным, и он может побить в скорости сами плюсы. Однако для серьезных проектов использовать rust слишком рискованно и преждевременно, особенно в наше время, когда уровень безумия и взаимного недоверия в международной политике просто зашкаливает, а некоторые технические детали реализации экосистемы rust являются более уязвимыми по отношению к злонамеренным действиям людей, чем у других языков программирования (не хочу спорить за очевидностью, и даже «cargo vendor» здесь не играет особой роли).

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

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

Зачем тогда спрашиваешь если во всем разобрался?

Я выразил своё видение ситуации, спросил, чтобы узнать альтернативные точки зрения.

Здесь и на ЛОРе об этом постоянно пишут.

Ну да, всемирно известные лоровские эксперты по «ненужно».

сделать как в C++

Лол, спасибо, не надо.

Вот также ёрничают над такими последователями cargo, как ты. И кстати, здесь на ЛОРе тоже. Вы не одиноки ;)

Лет через 10 или 20 модель распространения исходников через npm или cargo признают недостаточно надежной и, возможно, даже ошибочной и тупиковой.

А возможно не признают, а наоборот доработают и улучшат.

сделать как в C++

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

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

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

И попробуй ЗАСТРЕМАТЬ

Как Волшебные Русалки

pub fn new(secret_key: &SecretKey) -> Self {
            Self::_new(secret_key.unprotected_as_bytes()).unwrap()
        }
 
fn process_end_of_stream(&mut self) {
        // full carry h
        let mut h0: u32 = self.a[0];
        let mut h1: u32 = self.a[1];
        let mut h2: u32 = self.a[2];
        let mut h3: u32 = self.a[3];
        let mut h4: u32 = self.a[4];

        let mut c: u32 = h1 >> 26; h1 = h1 & 0x3ffffff;
        h2 += c; c = h2 >> 26; h2 = h2 & 0x3ffffff;
        h3 += c; c = h3 >> 26; h3 = h3 & 0x3ffffff;
        h4 += c; c = h4 >> 26; h4 = h4 & 0x3ffffff;
        h0 += c * 5; c = h0 >> 26; h0 = h0 & 0x3ffffff;
        h1 += c;
        // compute h + -p
        let mut g0: u32 = h0.wrapping_add(5); c = g0 >> 26; g0 &= 0x3ffffff;
        let mut g1: u32 = h1.wrapping_add(c); c = g1 >> 26; g1 &= 0x3ffffff;
        let mut g2: u32 = h2.wrapping_add(c); c = g2 >> 26; g2 &= 0x3ffffff;
        let mut g3: u32 = h3.wrapping_add(c); c = g3 >> 26; g3 &= 0x3ffffff;
        let mut g4: u32 = h4.wrapping_add(c).wrapping_sub(1 << 26);
        // select h if h < p, or h + -p if h >= p
        let mut mask = (g4 >> (32 - 1)).wrapping_sub(1);
        g0 &= mask;
        g1 &= mask;
        g2 &= mask;
        g3 &= mask;
        g4 &= mask;
        mask = !mask;
        h0 = (h0 & mask) | g0;
    	h1 = (h1 & mask) | g1;
    	h2 = (h2 & mask) | g2;
    	h3 = (h3 & mask) | g3;
    	h4 = (h4 & mask) | g4;
        // h = h % (2^128)
        h0 = ((h0) | (h1 << 26)) & 0xffffffff;
        h1 = ((h1 >> 6) | (h2 << 20)) & 0xffffffff;
        h2 = ((h2 >> 12) | (h3 << 14)) & 0xffffffff;
        h3 = ((h3 >> 18) | (h4 << 8)) & 0xffffffff;
        // mac = (h + pad) % (2^128)
        let mut f: u64 = (h0 as u64) + (self.s[0] as u64); h0 = f as u32;
        f = (h1 as u64) + (self.s[1] as u64) + (f >> 32); h1 = f as u32;
        f = (h2 as u64) + (self.s[2] as u64) + (f >> 32); h2 = f as u32;
        f = (h3 as u64) + (self.s[3] as u64) + (f >> 32); h3 = f as u32;
        // Set self.a to MAC result
        self.a[0] = h0;
        self.a[1] = h1;
        self.a[2] = h2;
        self.a[3] = h3;
    }

pub fn seal(
    secret_key: &SecretKey,
    nonce: &Nonce,
    plaintext: &[u8],
    ad: Option<&[u8]>,
    dst_out: &mut [u8],
) -> Result<(), UnknownCryptoError> {
    match plaintext.len().checked_add(POLY1305_OUTSIZE) {
        Some(out_min_len) => {
            if dst_out.len() < out_min_len {
                return Err(UnknownCryptoError);
            }
        }
        None => return Err(UnknownCryptoError),
    };

    let mut enc_ctx =
        ChaCha20::new(secret_key.unprotected_as_bytes(), nonce.as_ref(), true).unwrap();
    let mut tmp = Zeroizing::new([0u8; CHACHA_BLOCKSIZE]);

    let pt_len = plaintext.len();
    if pt_len != 0 {
        dst_out[..pt_len].copy_from_slice(plaintext);
        chacha20::xor_keystream(&mut enc_ctx, ENC_CTR, tmp.as_mut(), &mut dst_out[..pt_len])?;
    }

    let mut auth_ctx = Poly1305::new(&poly1305_key_gen(&mut enc_ctx, &mut tmp));
    let ad = ad.unwrap_or(&[0u8; 0]);
    process_authentication(&mut auth_ctx, ad, &dst_out[..pt_len])?;
    dst_out[pt_len..(pt_len + POLY1305_OUTSIZE)]
        .copy_from_slice(auth_ctx.finalize()?.unprotected_as_bytes());

    Ok(())
}

фернандос - это фрактал.

лол, выходит не я один так думаю

а уж если что-то большое перепиливать…

То меняешь что надо, а потом правишь ошибки компиляции.

Сорян чувак, дай больше контекста, ни куя не понятно что ты там хотел донести. Код как код, единственно макросы бы накатил для удобочитаемости. А так такая кака на всех ЯП будет выглядеть так же +-.

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

Впрочем, и до операции h % (2^128) можно было использовать типы подлиннее.

Именно поэтому rust много лет в любимых языках по опросам

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

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

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

Пока rust об этом не задумывается. Ибо нет динамической линковки. А ее нет потому что нет зафксированного ABI.

Вот лет через 10 - 20, может быть, зафксируют аби. Еще через 10 доделают динамическую линковку. Еще через 10 придут к разделению на декларацию и реализацию. И тогда API будут ломать в разы реже. И еще лет через 10 наконец будет можно использовать в своих проектах пакеты из дистрибутивов. А до тех пор только песочница (cargo, качающий все их инета).

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