Презентация «Rust Me, I'm a Developer!»

Я где-то написал, что не серьезнее? Конечно, серьезнее, но пока говорить о больших проектах рано, ИМХО.

Разыменование может сломать

Это как? то есть понятно, что raw pointer это штука не безопасна

Хм. То есть ты понимаешь, что raw pointer небезопасен, но не понимаешь, как он может что-то сломать?

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

Капитан просил передать, что если ты будешь писать на Rust, как на Си, то ты получишь все проблемы Си. И да, на Rust можно писать, как на Си, но зачем?

пока говорить о больших проектах рано, ИМХО.

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

вот, кстати пример

fn main( ) {


    let mut x = Point {x: 1.0, y: 2.0};
    let mut t = PointOther{p: &x, y: 100.0};
    
    loop {
        let y = Point{ x: 0.0, y: 0.0 };
        let t = PointOther{p: &x, y: 100.0}; 
        t = PointOther{ p: &y, y: 0.0 };
        break;
    }

    x = Point{x: 100.0, y: 10.99};
    unsafe {
        println!("{:?}", *t.p);
    }
}

отдает на выходе 0; 0 то есть raw не совсем raw. он всёж держит ссылку на объект, или объект, всёж сдох, а по указателю уже невалидная память?

Капитан просил передать

еще он просил передать, что на С++ тоже можно пользовать shared_ptr, вместо raw, что между потоками можно организовать очереди сообщений, и что в функции можно отдавать константные ссылки на локальные объекты, которые живут только в одном потоке.

на С++ тоже можно пользовать shared_ptr, вместо raw

А на Rust ты почему-то использовал raw pointer.

[...]

Да, конечно. Только на Си++ все эти хорошие практики не проверяются компилятором

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

на Rust можно писать, как на Си

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

на Си++ все эти хорошие практики не проверяются компилятором

на Rust ты почему-то использовал raw pointer.

А на rust проверяются? Или все-таки можно использовать raw pointer и все поломать?

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

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

если все эти чудеса не обязательные, и плохой код писать все-таки можно, то зачем тогда вообще нужен rust?

А... то есть языки, позволяющие писать плохой код, не нужны? «Из какого класса гимназии вас вытурили за неуспешность?» (ц)

на rust проверяются?

Да, owned pointers в Rust проверяются, в отличие от uniq_ptr в Си++.

http://rustbyexample.com/

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

А на Rust ты почему-то использовал raw pointer.

не, ну если кичиться своей супер-безопасностью, то безопасностью во всём. А тут оказывается и unsafe порой нужен, и raw не пользовать. Ты же понимаешь, что если есть возможность отстрелить себе яйца, то обязательно найдется тот, кто отстрелит. А потом будет «это не язык кривой, это руки из жопы». Ну так вот я и говорю, что рукожопы в любой системе найдут, где запнуться.

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

пф. посмотрим, что с рустом будет лет этак через 10-15 (если не забросят).

К сожалению тенденция среди «девелоперс» отнюдь ни в пользу интеллекта, внимательности и понимая сути вещей (у меня вон полный стол резюме, и все - львы толстые ... ). Как только начнутся на нем проекты, писаные НЕ авторами языка, вот тогда и начнутся красивые легаси-костыли.

не, ну если кичиться своей супер-безопасностью

«Кичиться»? Где ты это увидел? Во фразе «safe by default»?

оказывается и unsafe порой нужен, и raw не пользовать

«Оказывается»? Даже не знаю, откуда ты черпаешь знания о Rust, если для тебя это неожиданность.

пф. посмотрим, что с рустом будет лет этак через 10-15 (если не забросят).

Да. И посмотрим, что будет за то же время с Си++.

Тут просто очень долго втирали

Да в твоей вселенной и на brainfuck много чего написали.

А оказывается, что волшебства нет

Кстати, Деда Мороза тоже нет. Ну, если ты еще не знаешь.

«Оказывается»? Даже не знаю, откуда ты черпаешь знания о Rust, если для тебя это неожиданность.

от спецов типа tailgunner.

Да. И посмотрим, что будет за то же время с Си++.

дай ка вспомнить ... с 99 года на лоре эту мантру слышу. «вот %COMPANY_NAME% сделали %LANGUAGE_NAME%, теперь си++шечке, а тем более сишечке точно п..ц!». дада. так всё и есть.

Даже не знаю, откуда ты черпаешь знания о Rust, если для тебя это неожиданность.

от спецов типа tailgunner.

Ссылки или GTFO.

с 99 года на лоре эту мантру слышу. «вот %COMPANY_NAME% сделали %LANGUAGE_NAME%, теперь си++шечке, а тем более сишечке точно п..ц!»

Это у тебя полушария диалог ведут.

а что, видео нет?

Ссылки или GTFO.

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

ну а чего вы тут недовольны все?

Школота и олдфаги всегда недовольны.

Даже не знаю, откуда ты черпаешь знания о Rust, если для тебя это неожиданность.

от спецов типа tailgunner.

Ссылки или GTFO.

перечитай свои сообщения тут

«Я знал, что ты скажешь это» (ц)

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

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

Её действительность никак не связана с возможностью модификации объекта, на который она указывает.

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

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

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

Вот банальный пример, который -Wall -Wextra -pedantic не ловят:

include <iostream>

struct X {
        X(const int& n): ref(n) {}
        const int& ref;
};

int main(int ac, char** av) {
        int* a = new int(1);
        X b(*a);
        delete a;
        // тут с памятью, на которую ссылается b.ref, может произойти что угодно
        std::cout << b.ref << std::endl; 
}

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

Костыли вы мои костыли...

А если развернуто? Я вот не вижу, почему использование идентификаторов объектов - костыль.

Вариант с unsafe, конечно, негодный.

И каюсь, да, у меня из головы вылетели варианты с RC и GC, которые тут бы подошли.

Ты явно C++ не знаешь, так как ты можешь оценивать чужие знания C++

Явно? Мне вот не явно с чего ты так решил. «Знаю», конечно, размытое понятие, от корки до корки последний стандарт я не помню :) .

А можно продемонстрировать эти варианты с RC и GC на моем примере (который обсуждали на первой странице)?

то есть raw не совсем raw. он всёж держит ссылку на объект, или объект, всёж сдох, а по указателю уже невалидная память?

Он просто сырой, ничего он не держит. Это прямой аналог указателя из Си. Указатель указывает на уже недействительный кусок стека.

Указатель указывает на уже недействительный кусок стека.

То есть, ваш пример Презентация «Rust Me, I'm a Developer!» (комментарий) можно написать и на русте, и он так же полезет читать непонятно куда?

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

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

Вот банальный пример, который -Wall -Wextra -pedantic не ловят

~$ scan-build clang++ 1.cpp
scan-build: Using '/usr/bin/clang' for static analysis
1.cpp:13:22: warning: Use of memory after it is freed
        std::cout << b.ref << std::endl; 
                     ^~~~~

То есть, ваш пример Презентация «Rust Me, I'm a Developer!» (комментарий) можно написать и на русте, и он так же полезет читать непонятно куда?

Без unsafe секции - нельзя.

А в unsafe можно все, ты же говоришь компилятору, что умнее его. Как я уже написал, суть в том, что ты явным образом указываешь на опасность.

Круто! А g++ не поймал, зараза.

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

О, раз у тебя под рукой clang... он ловит эту ошибку:

#include <memory>
#include <iostream>

using namespace std;

int main()
{
   std::unique_ptr<int> x(new int(2));
   std::unique_ptr<int> y(std::move(x));

   cout << *x << endl;
   return 0;
}

не нашло, с -fsanitize=address в рантайме словило, но это конечно слабое утешение

Хм, как-то так, наверное:

cat test.rs

use std::cell::RefCell;
use std::rc::Rc;

struct Config {
    // для примера предположим, что в конфиге есть просто какое-то значение
    some_value: int,
}

struct ConfigManager {
    configs: Vec<Rc<RefCell<Config>>>,
}

impl ConfigManager {
    fn new() -> ConfigManager {
        ConfigManager{configs: Vec::new()}
    }

    fn get(&mut self, _: &Path) -> Rc<RefCell<Config>> {
        // для примера при создании положим в конфиг 1
        let config = Rc::new(RefCell::new(Config{some_value: 1}));
        self.configs.push(config.clone());
        config
    }

    fn reload(&mut self) {
        for config in self.configs.mut_iter() {
            // тут должны бы читаться обновленные значения,
            // но для примера просто обновим значение на 2.
            config.borrow_mut().some_value = 2;
        }
    }
}

struct SomeSystem {
    config: Rc<RefCell<Config>>,
}

impl SomeSystem {
    fn new(config_manager: &mut ConfigManager) -> SomeSystem {
        let config = config_manager.get(&Path::new("bin/conf.json"));
        SomeSystem{config: config}
    }
}

fn main() {
    let mut config_manager = ConfigManager::new();
    let system = SomeSystem::new(&mut config_manager);
    println!("{}", system.config.borrow().some_value); // "1"
    config_manager.reload();
    println!("{}", system.config.borrow().some_value); // "2"
}

$ rustc test.rs && ./test
1
2
$ 

Замечательно, только это никак не связано с константностью.

Очередное уродство, а не язык :'(

Очередное уродство, а не язык :'(

Вкусовщина в чистом виде. Да и смотря с какими языками сравнивать.

Как по мне, так вполне нормально.

Что именно в синтаксисе (или еще в чем) вызвало столько эмоций, если не секрет?

Видео нет, насколько я знаю. Просто презентация.

Замечательно, только это никак не связано с константностью.

Очень даже связано с неизменяемостью и «заморозкой» в Ржавчине, я же писал выше. Можешь пояснить, что ты имеешь ввиду?

пф. посмотрим, что с рустом будет лет этак через 10-15 (если не забросят).

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

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

Яйца тут ни при чем. Тут нужно мало пользователей языка и проектов на нем.

Яйца тут ни при чем. Тут нужно мало пользователей языка и проектов на нем.

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

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

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

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

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

Спорно. Как по мне, так тянуть обратную совместимость со всяким хламом десятилетиями - вот это не разумно.

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

Эй, сюда-то политоту зачем тянуть? Других тем мало?

Чего тут спорного, если тебя пользователи пошлют на куй вместе с твоей новой замечательной версией? Питон 3 и тот посылают...

Я не полностью понимаю, что происходит в данном примере, но мне в нем не нравятся две вещи:

• объект ConfigManager передаётся как &mut только для вызова get-метода, который, я так понял, не изменяющим объект в принципе не сделаешь. На мой взгляд это очень плохо.
• Ощущение складывется, что ты сейчас расстреллял маленького воробья из огромной пушки. Да и если смотреть на всё это крестовыми глазами, то на ровном месте насоздавали объектов. Возможно раст это всё сведет к простым ссылкам, но без уверенности в этом, я бы такой код писать постеснялся.

объект ConfigManager передаётся как &mut только для вызова get-метода, который, я так понял, не изменяющим объект в принципе не сделаешь. На мой взгляд это очень плохо.

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

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

Ощущение складывется, что ты сейчас расстреллял маленького воробья из огромной пушки. Да и если смотреть на всё это крестовыми глазами, то на ровном месте насоздавали объектов. Возможно раст это всё сведет к простым ссылкам, но без уверенности в этом, я бы такой код писать постеснялся.

Смотря какими крестовыми глазами смотреть - на плюсах-то можно очень по-разному писать :).

Данный пример мало отличается от использования std::shared_ptr. Как еще гарантировать, что ссылка на объект будет действительна?

В принципе, можно убрать Rc и использовать просто RefCell (эта штука обходит заморозку). Но тогда ты получаешь те же недостатки, что и с сохранением ссылки в объекте в С++. Разница в том, что использование RefCell - идентификатор опасного места, как и unsafe-секции, а в С++ небезопасное поведение используется по-умолчанию.

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

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