1. Куча / Говнокод #26927

    +3

    1. 01
    2. 02
    3. 03
    4. 04
    5. 05
    6. 06
    7. 07
    8. 08
    9. 09
    10. 10
    11. 11
    12. 12
    13. 13
    14. 14
    15. 15
    16. 16
    17. 17
    18. 18
    19. 19
    20. 20
    21. 21
    22. 22
    23. 23
    24. 24
    25. 25
    26. 26
    27. 27
    В чём прикол "Go"?
    
    Попробовал сделать примитивное апцо - это сущий пиздец. Нельзя просто взять и на лету
    сформировать с нуля массив и отобразить его в виде "JSON" - надо под все случаи прописать
    какие-то долбоёбские структуры и строго их придерживаться. Нельзя просто так взять и
    закомментировать абы какую строку - под это приходится ломать и крушить половину кода
    в файле.
    
    Говорят, что это нужно для какой-то дисциплины, но схуяли программист не может распоряжаться
    СВОИМ кодом по своему усмотрению? С каких пор компилятор учит программиста стилю кода?
    В этом говноязыке чувствуешь себя, как на зоне.
    
    Очень гадостно в этом языке работать с базами данных.
    
    Я было обрадовался, что наконец-то появился язык, официально как будто не дающий возможности
    технически реализовать ООП-подход и ломающий стереотип о необходимости влажных фреймворков,
    но на деле это оказалось той же пиздой, только в другой обёртке.
    
    Поэтому я за "PHP".
    
    В нём я просто создаю на лету массив произвольной структуры и тут же превращаю его в "JSON".
    В нём я просто комментирую ту строку, которая мне в данный момент не нужна. В нём я просто
    создаю подключение к "MySQL" и использую его в коде даже без отсылки к переменной подключения.
    Наконец, в нём я могу не использовать ООП, если не хочу (а я не хочу).
    
    "PHP" переживает все другие языки для серверной разработки. "Ruby" мёртв, "Python" мёртв, "Java" и
    "NodeJS" уже подыхают, на очереди, я так понимаю, как раз "Go". И только "PHP" на коне.

    Запостил: urinoterapevt, 07 Сентября 2020

    Комментарии (152) RSS

    • https://www.phoronix.com/forums/forum/software/programming-compilers/1203440-linux-developers-continue-evaluating-the-path-to-adding-rust-code-to-the-kernel

      I really don't understand this masturbation about rust. C doesn't work? C++ doesn't work? Assembly doesn't work?
      
      It seems that Mozilla that shoves Rust down everyone's throat. Another thing is that now it seems that it has become fashionable to rewrite everything in Rust.
      
      I don't say that as a programmer, but as a user. Every time I needed to compile something that needed Rust in Gentoo, it was absurd the time needed to compile compared to something written in C or C++. 
      
      Rust is bloated as hell.
      Ответить
      • показать все, что скрытоvanished
        Ответить
        • Ну ниже он даёт веский аргумент:
          >it was absurd the time needed to compile compared to something written in C or C++

          Притом что кресты раньше обычно считались за днище по скорости компиляции.
          Ответить
          • Дык там вроде всегда вся прога целиком компилится... Или уже завезли сборку отдельных модулей?
            Ответить
            • Там же издавна crates.

              Но в целом, пuтушатня компилится раз в 10 медленее аналогичной сишки.
              Ответить
              • Кстати а у них компилятор сам на себе написан?
                Ответить
                • Всё кроме бэкэнда (llvm) вроде на нём.
                  Ответить
                  • The self-hosted compiler — the second version of the compiler, written in Rust and compiled with the bootstrap compiler — has grown by 3800 lines and is now capable of lexing, parsing, and translating some minimal programs (hello world, various expressions) through LLVM to executable code.
                    Ответить
                • Хз.

                  Смотря что понимать под компилятором.

                  Крестовый LLVM-бекэнд? Или разбирающий пuтуха фронт для LLVM? Он как я слышал на дrustне.

                  Так-то замечание верное: без использования unsafe/сишных биндингов пuтушатня работает в разы медленее.

                  Потому все рассказы про zero cost abstraction — враньё и пропаганда.
                  Ответить
                  • > медленнее

                    Но почему? Много лишних копирований из-за того, что чекер по ссылке передать не даёт?
                    Ответить
                    • > Rust is anti-FORTRAN in a sense that FORTRAN was all about arrays and could operate arrays safely while Rust safely prevents you from operating arrays.

                      >Много лишних копирований
                      Ещё я слышал что они делают runtime bounds checking.
                      Звучит конечно смешно и печально.
                      После сказок о ма-те-ма-ти-че-ски доказанной корректности языка.

                      Так-то я не знаю. Наверное дело в анскильности.
                      Ответить
                      • > while Rust safely prevents you from operating arrays.

                        Как они умудрились это-то сломать? Какой прогресс )))
                        Ответить
                        • Они же хотят всё делать безопасно.

                          Когда их спрашивают: а чего это у вас runtime проверки?

                          https://stackoverflow.com/a/28389701

                          Они отвечают: «а мы нихуя не умеем» и перекладывают ответственность на рантайм и шланг.

                          Для проверок в compile-time нужно пилить «систему типов с диапазонами». (см. тред: https://govnokod.ru/26515#comment535139)

                          А раст-отребье слишком анскильно для такой задачи.
                          Ответить
                          • > систему типов с диапазонами

                            Забавно, что и гцц и шланг умеют доказывать несложные утверждения даже без такой системы. Т.е. в том же алгоритме двоичного поиска, скорее всего, они не будут вставлять проверки в колёса.
                            Ответить
                          • показать все, что скрытоvanished
                            Ответить
                            • https://ideone.com/rmZs9Q

                              Ты про это?

                              При включенном «range checking» ($R+) сначала компилятор попытается проверить выражения, которые считаются в компилтайме (в вышеуказанном реальном примере он сразу выкинул и не стал дальше компилировать, потому что константа выходит за диапазон), а если в компилтайме ничего криминального нет, то он будет производить проверки в рантайме при каждом присвоении, как в следующем реальном примере:
                              https://ideone.com/g1ajss
                              Ответить
                              • > если в компилтайме ничего криминального нет, то он будет производить проверки в рантайме при каждом присвоении

                                Чем это хуже Пuтушатни — непонятно.

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

                                Притом скорость компиляции Паскаля огромна, в силу его простоты.
                                Ответить
                      • Без runtime bounds checking только какой-нибудь кок с зависимыми типами может прожить... Ну или няшная с крестами, где всё под твою ответственность.
                        Ответить
                        • Самое смешное, что они и здесь обосрались и, как водится, переложили ответственность на старшего.

                          In safe Rust bounds checks elimination is left up to LLVM. Iterator’s next() is inlined, so the optimizer can see what actually is checked and doesn’t need to create a literal Some/None wrapper at any point.

                          For slices there’s also get_unchecked() which you can use when you are sure the check is not needed.


                          https://users.rust-lang.org/t/iterators-and-eliminating-all-runtime-bounds-checks/13935/3

                          Царь был прав. Пuтушатня нихуя сама не может. Всё быстрое и хорошее там либо ворованное, либо unsafe.
                          Ответить
                          • > переложили ответственность

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

                            > when you are sure

                            А вот это зашквар, конечно. Если я так в себе уверен, то зачем мне раст? Ладно бы что-то невозможное через unsafe делать. Но тут он на ровном месте ради пирфоманса...
                            Ответить
                            • Зиро ко-ко-кост абастракшн, да.
                              Ответить
                              • Если ещё учесть их нападки на GC, то

                                Zero-co-co-cost malloc!
                                Zero-co-co-cost free!
                                Zero-co-co-cost bounds checking!
                                Ответить
                            • >Ну а почему нет? Если там эта механика уже запилена и несложные утверждения о значениях вполне доказывает.

                              Потому что это нивелирует все заявления о премиуществах пuтушатни.
                              Если проверки убирает LLVM-бекэнд, то любой llvm-based ЯВУ может быть не менее «безопасным».
                              Ответить
                          • Хочу езык с пердикатами. Чтобы можно было конпелятору говорить, что «petuhLen» — это длина моссива «petuh», и проверять баунды нинужно. А если длина не известна — тогда нужно.
                            Ответить
                            • Ну вот мы знаем, что i < petuhLen. Я прибавляю к i сорок два. Что теперь делать конпелятору?

                              А массивы ведь для произвольного доступа и нужны.

                              З.Ы. Именно поэтому функцианальщики обычно всё доказывают на каких-нибудь списках или деревьях, а массивы обходят стороной.
                              Ответить
                              • > а массивы обходят стороной

                                Последователи функциональной парашдигмы придумали себе Separation logic, так что не всё так печально с массивами уже. Правда пока все имплементации, что я видел, выглядят в лучшем случае как embedded DSL. Но может когда-нибудь это нативно прикрутят.

                                Если не бояться ебануться наотличненько, то можно установить с опама исследовательский проект "iris" и сказать, что в Coq завезли O(1) векторы.
                                Ответить
                                • > что в Coq завезли O(1) векторы.
                                  Кстати Coq — хороший, правильный Петух.

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

                                  Люди не полагаются на шланг, а делают в компайл-тайме пруфы ку-ка-ректности (coq correct) обращений к массивам:
                                  http://adam.chlipala.net/cpdt/html/MoreDep.html
                                  Ответить
                                  • Кстати да, на нём ещё написан CompCert, компилятор няшной, с помощью которого вроде даже можно доказывать какие-то свойства царских программ. Правда, насколько я знаю, этим никто не пользуется. Какая жалость (((
                                    Ответить
                                    • > Кстати да, на нём ещё написан CompCert, компилятор няшной, с помощью которого вроде даже можно доказывать какие-то свойства царских программ. Правда, насколько я знаю, этим никто не пользуется. Какая жалость (((

                                      Это потому что он проприетарный
                                      Ответить
                              • > Ну вот мы знаем, что i < petuhLen. Я прибавляю к i сорок два. Что теперь делать конпелятору?
                                Если компилятор сможет доказать, что ∀i: i + 42 < petuhLen, то ничего. Если сможет доказать, что ∃i: i + 42 < petuhLen (например, у нас цикл «i in 0..petuhLen»), то кидать ошибку. Если не сможет ни того, ни другого — выдавать предупреждение, наверное.
                                Ответить
                                • Ну проблема в том, что для мало мальски сложного алгоритма хрен ты что докажешь. Понадобятся более сложные утверждения в духе "эти массивы одинаковой длины" или "выходной массив вдвое длинее входного". И ты постепенно получишь очередной язык для Снаута.

                                  А с простыми кейсами в духе "я вот только что проверил" или "мне просто циклом пробежаться" конпеляторы и сейчас справляются. Без всяких аннотаций.
                                  Ответить
                                  • > И ты постепенно получишь очередной язык для Снаута.
                                    Как что-то плохое.
                                    Ответить
                              • > Я прибавляю к i сорок два. Что теперь делать конпелятору?

                                Универсального алгоритма нет, но есть довольно мощные эвристики, к примеру Coq умеет довольно автоматически многие системы неравенств решать, включая про +42:

                                https://coq.inria.fr/refman/addendum/omega.html
                                https://coq.inria.fr/refman/addendum/micromega.html#coq:tacn.lia
                                Ответить
                                • Кстати, а есть какой-нибудь годный туториал по петуху?
                                  Ответить
                                  • Да, вот очень доступная книжка:

                                    https://softwarefoundations.cis.upenn.edu/current/lf-current/lf.tgz (вся серия тут: https://softwarefoundations.cis.upenn.edu/current/index.html )

                                    Начальных знаний не требует, кроме базовой функцональщины. Крайне советую читать эту книжку через CoqIde или в Emacs, распаковав её исходники куда-нибудь локально, и выполняя код и решая упражнения прямо по ходу чтения, и поглядывая на порядок глав в deps.gif.
                                    Ответить
                                    • Спасибо! А IDE там нужно из-за интерактивности, чтобы после каждой строчки ответ конпелятора смотреть?
                                      Ответить
                                      • Да. Coq очень интерактивный, и позволяет, грубо говоря, открыть файл, зайти внутрь функции, и посмотреть, как оно там. Как следствие, редактор должен хорошо поддерживать протокол общения с прогой coqtop, которая что-то вроде смеси code server, REPL и jupiter notebook. Есть две взрослые программы для этого: proof-general (плагин для Emacs) и CoqIde, гуёвая тулза. Может и для других редакторов что-то есть, но я это не трогал.
                                        Ответить
                            • показать все, что скрытоvanished
                              Ответить
                              • Так не интересно, так и в крестах можно.
                                std::vector<Petuh> petuhis;
                                for (size_t i = 0; i < petuhis.size(); i++) {
                                    std::cout << petuhis[i].koko() << std::endl;  // uncheck_bounds
                                }
                                
                                for (size_t i = 0; i < petuhis.size(); i++) {
                                    std::cout << petuhis.at(i).koko() << std::endl;  // check_bounds
                                }
                                Ответить
                                • показать все, что скрытоvanished
                                  Ответить
                                  • За каким хуем он должен быть виртуальным.
                                    Тут вам не джэйвэ.
                                    Ответить
                                    • показать все, что скрытоvanished
                                      Ответить
                                      • он все знает про вектор, ведь вектор это хедер онли класс
                                        Ответить
                                        • показать все, что скрытоvanished
                                          Ответить
                                          • разве робот может написать симфонию?

                                            прочитай еще раз что тебе гост написал

                                            operator [] как раз не проверяет границы (хотя я бы не исключал, что -Warray-bounds там кое-что будет уметь)

                                            а .at() проверяет
                                            Ответить
                                            • показать все, что скрытоvanished
                                              Ответить
                                              • надо быть супер-анскильным, если постоянно допускать выход за пределы массива -- это когда уже итерироваться в крестах можно форычем скоро лет 10 как

                                                в чем должна быть магия?
                                                Ответить
                                              • > А тут магия просто в том, что в at() есть код для проверки, а в свобочках нету?
                                                На уровне синтаксиса — да. operator[]() у вектора сделан максимально быстрым и никаких «исключений» не содержит, вышел за перделы массива — сам дурак. В at(), напротив, рантайм-проверки есть.

                                                Магию делает конпелятор, например: https://gcc.godbolt.org/z/v3EMM3.
                                                #include <vector>
                                                #include <cinttypes>
                                                
                                                uint64_t get_sum_1(const std::vector<uint64_t> & vec) {
                                                    uint64_t sum = 0;
                                                    for (size_t i = 0; i < vec.size(); i++) {
                                                        sum += vec.at(i);
                                                    }
                                                    return sum;
                                                }
                                                
                                                uint64_t get_sum_2(const std::vector<uint64_t> & vec, size_t max_idx) {
                                                    uint64_t sum = 0;
                                                    if (max_idx > vec.size()) {
                                                        max_idx = vec.size();
                                                    }
                                                    for (size_t i = 0; i < max_idx; i++) {
                                                        sum += vec.at(i);
                                                    }
                                                    return sum;
                                                }

                                                В get_sum_1() конпелятор догадался, что проверки в at() лишние, и сделал максимально простой цикл без лишних телодвижений. А вот в get_sum_2(), к сожалению, не догадался: туповат-с.
                                                Ответить
                                                • показать все, что скрытоvanished
                                                  Ответить
                                                  • Там всё заинлайнилось, скорее всего. at() выглядит как-то так:
                                                    const T & at(size_t i) const {
                                                        if (i >= this.size()) {
                                                            throw new Zascheka("Out of range");
                                                        }
                                                        return this._mossiv[i];
                                                    }

                                                    После инлайна получилось что-то такое (условно, конечно, это же не дефайны, чтобы их так дословно раскрывать):
                                                    for (size_t i = 0; i < vec.size(); i++) {
                                                        if (i >= this.size()) {
                                                            throw new Zascheka("Out of range");
                                                        }
                                                        sum += this._mossiv[i];
                                                    }

                                                    Ну вот конпелятор и сумел доказать, что if тут лишний.
                                                    Ответить
                                                    • показать все, что скрытоvanished
                                                      Ответить
                                                      • vec.size() это же тоже vec._skolkoRealnoHranimSejchas
                                                        Ответить
                                                      • > Для этого он должен знать, что такое "vec.size()"
                                                        Зачем? Ему на это похуй, он просто видит лишние сравнения и течёт.

                                                        > что такое "for"
                                                        Ну, инвариант сишного фора не особо сложно вывести, он там во второй колонке.
                                                        Ответить
                                                        • показать все, что скрытоvanished
                                                          Ответить
                                                          • если KAKOTEPEPEPETL() заинлайнится, то компилятор сможет доказать, что там нет сайд эффектов
                                                            если нет, то не сможет
                                                            Ответить
                                                          • Да. https://gcc.godbolt.org/z/73GMGs
                                                            #include <vector>
                                                            #include <cinttypes>
                                                            
                                                            struct Mossiv {
                                                                size_t size = 0;
                                                                
                                                                size_t get_size() const noexcept {
                                                                    return this->size;
                                                                }
                                                                
                                                                uint64_t at_runtime_check(size_t idx) const {
                                                                    if (idx >= this->get_size()) {
                                                                        throw "kakou barop )))";
                                                                    }
                                                                    return 42;
                                                                }
                                                            };
                                                            
                                                            uint64_t get_sum_1(const Mossiv & mossiv) {
                                                                uint64_t sum = 0;
                                                                for (size_t i = 0; i < mossiv.get_size(); i++) {
                                                                    sum += mossiv.at_runtime_check(i);
                                                                }
                                                                return sum;
                                                            }
                                                            
                                                            uint64_t get_sum_1(const Mossiv & mossiv, size_t max_size) {
                                                                    uint64_t sum = 0;
                                                                for (size_t i = 0; i < max_size; i++) {
                                                                    sum += mossiv.at_runtime_check(i);
                                                                }
                                                                return sum;
                                                            }
                                                            Ответить
                                                • А вообще, конечно, из get_sum_2() проверки убрать нельзя: у нас в середине цикла вектор может измениться — и бо-бо.
                                                  Ответить
                                                  • >А вот в get_sum_2(), к сожалению, не догадался: туповат-с.

                                                    Починил, проверь.
                                                    Хотя, не. Туповат-с
                                                    Ответить
                                                    • Лол, он реально туповат. Внутренние представления в питухах со знаком что ли?..
                                                      UPD: А, не, в жирной строчке max_idx просто присвоится vec.size() же. Так не интересно.
                                                      Ответить
                                                      • >Внутренние представления в питухах со знаком что ли?

                                                        Я тоже сначала так подумал. А потом с горечью осознал что ошибся при копипасте:

                                                        >UPD: А, не, в жирной строчке max_idx просто присвоится vec.size() же.
                                                        Ответить
                                                      • Таки починил.
                                                        Таки туповат.
                                                        #include <vector>
                                                        #include <cinttypes>
                                                        
                                                        uint64_t get_sum_2(const std::vector<uint64_t> & vec, size_t max_idx) {
                                                            uint64_t sum = 0;
                                                            for (size_t i = 0; i < max_idx && i<vec.size(); i++) {
                                                                sum += vec.at(i);
                                                            }
                                                            return sum;
                                                        }

                                                        Причём казалось бы говнище: vec.size() постоянно дрочим внутри цикла. А оказывается оптимальным кодом.

                                                        https://gcc.godbolt.org/z/x5rq4j

                                                        Короче я понял, там эвристика расчитывает на идиоматичное i<vec.size() в условии или в бряке сверху(что одно и то же).
                                                        Ответить
                                                        • Пишем идиоматично, компилятор догадывается вынести сравнения в пролог — в цикле нет проверок.
                                                          for (size_t i = 0;  i < vec.size(); i++) {
                                                                  if (i >= max_idx) break;
                                                                  sum += vec.at(i);
                                                          }
                                                          .L11:
                                                                  add     r8, QWORD PTR [rdx+rax*8]
                                                                  add     rax, 1
                                                                  cmp     rsi, rax
                                                                  ja      .L11

                                                          Меняем местами
                                                          for (size_t i = 0;  i < max_idx; i++) {
                                                                  if (i >= vec.size()) break;
                                                                  sum += vec.at(i);
                                                          }
                                                          И получается хуйня
                                                          .L19:
                                                                  add     r8, QWORD PTR [rcx+rax*8]
                                                                  add     rax, 1
                                                                  cmp     rsi, rax
                                                                  je      .L14
                                                          .L16:
                                                                  cmp     rdx, rax
                                                                  jne     .L19


                                                          Аналогично компилятор не в состоянии оптимизировать 2 условия
                                                          for (size_t i = 0;  i < max_idx && i<vec.size(); i++) {
                                                                  sum += vec.at(i);
                                                              }

                                                          https://gcc.godbolt.org/z/8hWT3j
                                                          Ответить
                  • Раст и переполнения чисел: The program won’t panic, but the variable will have a value that probably isn’t what you were expecting it to have.

                    Какая безопасность )))

                    Ну хоть не UB как в крестах, просто two's complement. Хотя разницы особо и нет, один хер прога выведет фигню.
                    Ответить
                    • Да это ещё похуй, хотя бы предсказуемое поведение. Удивительно то, что в ма-те-ма-ти-чес-ки до-ка-зан-ном numyxe бывают даже настоящие UB: http://govnokod.ru/26810.
                      Ответить
            • А какая разница, если там речь про пользовательскую сборку из исходников тулзей и либ. Ни модули, ни инкрементальная сборка тут ничего не дадут
              Ответить
      • Here we go again...
        
        I have already stated my opinion about Rust in older threads (the language itself and its community).
         I find the language a decent choice (I would not make that choice though) for many (maybe most) use cases, but it is not "a better C" (nor worse, just something else).
        
        However I hate its community, mainly because of some toxic minorities ("Everything should be written in Rust" guys, guys treating C and C++ as a single language etc).
        
        That being said, in order to have Rust in the Kernel, some red lines should be defined.
        Also the toxic guys should be kept out at all costs. My thoughts about red lines:
        0: C should be the only language needed to work with core Kernel stuff.
        Anything else should be used only for "leaf" stuff (like a driver for a specific device).
        1: There should be zero tolerance to guys proposing stuff like "lets rewrite the scheduler in Rust" or "lets implement the next-gen interrupt framework in Rust".
        
        And a final thought: Linus once said "[...] Quite frankly, even if the choice of C were to do nothing but keep the C++ programmers out, that in itself would be a huge reason to use C.". Are Rust programmers any better than C++ programmers?
        Ответить
        • показать все, что скрытоvanished
          Ответить
        • Комьюнити у раста и го - это просто пиздец, да. Юные прыщефанатики, которые раньше пытались впарить линукс всем подряд. Идеология примерно та же - если у вас есть проблемы с нашим замечательным языком, то ваш юзкейс "нинужен".
          Ответить
          • По этому я за луа
            Ответить
          • А у «PHP» комьюнити просто заебись.
            Ответить
          • я помню что как-то на меня удивленно смотрели, когда я охуевше узнал, что у го дженериков нет и зависимости прямо в гит-репозитории хранятся, и немедленно об этом сообщил
            Ответить
            • > зависимости прямо в репозитории

              Ну сэкономили на пакетном менеджере. У гугла ж одна репа на все, логично все зависимости там и хранить.
              Ответить
            • > и зависимости прямо в гит-репозитории хранятся

              Я помню в студии была замечательная прагма, позволяющая локальные(!) пути к либам прямо в сишниках хардкодить. Так что до гения мелкософта го немного не дотягивает.
              Ответить
              • Буст до сих пор её юзает. К слову, я из-за этого когда-то думал, что весь буст хедер онли. Пока на гцц не попытался прогу собрать.
                Ответить
                • Эта прагма вставляет в объектный файл комментарий, начинающийся с волшебного слова. Чтобы подхватилась нужная либа, линкер должен уметь парсить такие комментарии.
                  Ответить
            • Про зависимости не понял.

              Там же вроде gopath ебанутый, все дела
              Ответить
              • ну они вроде доросли до репозиториев, но go get github.com/... складывал это дело прямо в локальную папку, которая потом с упоением коммитилась гошником в свою удобную репу. сабмодули, очевидно, слишком сложно-абстракционный механизм.
                Ответить
                • Да вроде щас go get ставит в $GOPATH/src, по крайней мере, так было пару лет назад, когда я тыкал палочкой
                  Ответить
                  • моя палка старее

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

                    ну ничего, в го 2 точно починят
                    Ответить
                • Но там, впрочем, система ниппель всё равно:
                  - несколько версий одной зависимости емнип не поставить никак
                  - файла типа Package.json тоже не было, а потому каждая гоблядь должна была зависимости ставить руками (поймал себя на мысли, что в Рэкете такое же говно с этим, ну или я не шарю)

                  Может, что-то поменялось, конечно
                  Ответить
          • У С++ будто не такое :) "Наш язык мультипарашдигменный, это значит он заменяет все остальные языки. Какая функциональщина? Вот же царский boost::phoenix."
            Ответить
            • хз, вроде, все крестушки давно выросли из этого возраста
              тем более, что у крестов сейчас сегмент не "хочу", а "вынужден"
              ну, по моим личным ощущениям
              Ответить
              • > тем более, что у крестов сейчас сегмент не "хочу", а "вынужден"

                Даже после новых стандартов? Вроде наконец язык чинить начали после ада C++03.

                > вроде, все крестушки давно выросли из этого возраста

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

                  кресты это долго, дорого и охуенно
                  не всегда подходит, мягко говоря
                  Ответить
                  • > кресты это долго, дорого и охуенно

                    Скорее долго и охуенно дорого.
                    Ответить
                    • ну а кто у нас на ГК всё ещё профессионально занимается крестами?
                      gost?

                      если писать игоры, то, конечно, ты бы хотел максимум фпс на железе юзера
                      если упёрся в то, что на жабе тормозит бекенд яндекс карт, то тоже
                      если у тебя микроэвм с 128МБ рам, а всё ещё надо за микросекунды выполнять операции, то тоже

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

                  Вон даже на ГК вбросы про "кресты говно" уже не вызывают эмоций.
                  Ответить
    • I'd actually like Rust to replace C but not C++ because Rust simply doesn't cut it. 
      
      Something as simple as a dynamic mutable tree which would take a minute to implement in C++, is next to impossible in Rust
      
      I've spent 2 months and failed, because the naive online examples don't work IRL because of the borrow checker which makes to whole thing a total mess
      
       to this day I haven't seen a viable Rust solution, Mozilla's own Rust code from WebRender uses a JavaScript backend for this.
      Ответить
      • показать все, что скрытоvanished
        Ответить
        • В ядрах, где многие структуры входят одновременно в 100500 циклических списков и деревьев, борроу чекер особенно актуален. Раст и с одним то циклическим списком не справится без ансейфа. Да и с джвунаправленным вроде тоже.
          Ответить
          • Когда я его последний раз трогал (много лет назад), он и на односвязном обсирался. Пытался деструктор (или что там у него) для cons-cells рекуррентно вызвать и пробивал дно стека.
            Ответить
            • показать все, что скрытоvanished
              Ответить
              • Использовать то можно. А вот свои пилить только через боль и унижения.
                Ответить
                • >структуры данных
                  >свои пилить только через боль и унижения.

                  И мы опять приходим к тому, о чём я говорил...

                  Именно поэтому единственная вменяемая структура данных — одномерный массив.
                  Ответить
      • > next to impossible

        Блин, попробовать что ли по фану пильнуть дерево. Посмотреть хоть своими глазами на этот раст.
        Ответить
      • > The sheer amount of API to wrap

        Currently there is 11 THOUSAND lines of Rust in wlroots-rs. All of this code is just wrapper code, it doesn’t do anything but memory management. This isn’t just repeated code either, I defined a very complicated and ugly macro to try to make it easier.

        This wrapper code doesn’t cover even half of the API surface of wlroots. It’s exhausting writing wlroots-rs code, memory management is constantly on my mind because that’s the whole purpose of the library. It’s a very boring problem and it’s always at odds with usability - see the motivation for the escape from callback hell described above.

        To do all of this, and then go write Way Cooler, already a big undertaking, is too much for me to commit to. When the benefit at the end of the day is just so I don’t have to write C, that doesn’t really make it worth it. If I got this out of the box by simply linking to the library, like I can in C++, then it would be much more tenable.

        I can always just use unsafe bindings to wlroots, just like I would with any other language. However, the entire point of Rust is that it’s safe. Doing that is not an option because at that point you lose the entire benefit of the language.

        http://way-cooler.org/blog/2019/04/29/rewriting-way-cooler-in-c.html Стрелочка повернулась!
        Ответить
        • >Currently there is 11 THOUSAND lines of Rust in wlroots-rs. All of this code is just wrapper code, it doesn’t do anything but memory management. This isn’t just repeated code either, I defined a very complicated and ugly macro to try to make it easier.

          Какой пиздец )))

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

          Которые в итоге... всё-равно протекают.

          >I wish them luck, but I don’t feel interested in rewriting the entire world in Rust
          Ахаха.

          > Smithay [rust] is very incomplete. Very, very incomplete compared to wlroots. It is no where near usable and the current trajectory doesn’t look like it will be usable very soon either.
          > wlroots [C] is a great framework and has a strong backing in the community so I don’t see the need to abandon it just so I can keep using Rust.
          > I like Rust, but not enough to reinvent the wheel so it doesn’t have any C in it.

          Как там мантра «дак мы же как Сишка»?
          Ответить
          • А ты на расте писал?
            Ответить
            • Нет конечно. (если «писать» подразумевает программирование за деньги)

              Только тыкал в это палочкой.
              Потому моё мнение вряд ли претендует на объективность.
              Ответить
            • Роман пишет блокчейны на питузе, и вроде в каком-то треде о нём не слишком лестно отзывался. (на швабре это было: https://habr.com/en/post/484436/#comment_21153902)
              Ответить
    • Го следует принципам изначальной жабы - максимально простой язык за который можно посадить необученную макаку без боязни, что она что-нибудь сломает. Только в отличие от жабы тут ещё и исключения, дженерики и ООП отпилили.
      Ответить
    • показать все, что скрытоvanished
      Ответить
    • показать все, что скрытоvanished
      Ответить
    • показать все, что скрытоvanished
      Ответить
    • Павел сидел напротив и сверлил меня взглядом. Я не обращал на него никакого внимания, хотя понимал, что эта лекция пройдёт в жутком напряге и для меня, и для него. Просто на предыдущие он тупо не ходил.
      Ответить

    Добавить комментарий