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

    +2

    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

    Комментарии (150) 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.
      Ответить
      • I really don't understand this masturbation about $LANG_3. $LANG_1 doesn't work? $LANG_2 doesn't work? $LANG_0 doesn't work?

        Я не в защиту питуха, я просто не люблю такие аргументы
        Ответить
        • Ну ниже он даёт веский аргумент:
          >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)

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

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

                              Ты про это?

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

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

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

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

                                  Безграмотные миллениалы каждый год изобретают то, что было изобретено в 1960-м году, просто они слишкком тупы, чтобы это знать.
                                  Ответить
                      • Без 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, компилятор няшной, с помощью которого вроде даже можно доказывать какие-то свойства царских программ. Правда, насколько я знаю, этим никто не пользуется. Какая жалость (((
                                    Ответить
                              • > Ну вот мы знаем, что 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, гуёвая тулза. Может и для других редакторов что-то есть, но я это не трогал.
                                        Ответить
                            • или так

                              check_bounds {
                              foo[q]
                              }

                              uncheck_bounds {
                              for(..
                              }
                              Ответить
                              • Так не интересно, так и в крестах можно.
                                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
                                }
                                Ответить
                                • а в чем секрет? копулятор знает про вектор и скобочки квадратные и size? а если я наследуюсь и переопределю виртуально size?
                                  Ответить
                                  • За каким хуем он должен быть виртуальным.
                                    Тут вам не джэйвэ.
                                    Ответить
                                    • а, он не виртуальный там
                                      тогда ок

                                      но вопрос остался
                                      он знает про вектор?
                                      Ответить
                                      • он все знает про вектор, ведь вектор это хедер онли класс
                                        Ответить
                                        • в смысле это шаблон в .h файле?
                                          ок

                                          но как он может знать, что обращаться к [size() -1] безопасно?
                                          Ответить
                                          • разве робот может написать симфонию?

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

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

                                            а .at() проверяет
                                            Ответить
                                            • а) я неверно понял вообще всё.

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

                                              А тут магия просто в том, что в at() есть код для проверки, а в свобочках нету?

                                              Никакой магии вообще
                                              Ответить
                                              • надо быть супер-анскильным, если постоянно допускать выход за пределы массива -- это когда уже итерироваться в крестах можно форычем скоро лет 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(), к сожалению, не догадался: туповат-с.
                                                Ответить
                                                • >конпелятор догадался, что проверки в at() лишние,
                                                  а как?
                                                  Ответить
                                                  • Там всё заинлайнилось, скорее всего. 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 тут лишний.
                                                    Ответить
                                                    • Для этого он должен знать, что такое "vec.size()" и что такое "for".

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

                                                        > что такое "for"
                                                        Ну, инвариант сишного фора не особо сложно вывести, он там во второй колонке.
                                                        Ответить
                                                        • а) понял

                                                          for (....; i < KAKOTEPEPEPETL();....) {
                                                              if (i >= KAKOTEPEPEPETL()) {
                                                                  //вечный фолс
                                                              }
                                                          }

                                                          так?
                                                          Ответить
                                                          • если KAKOTEPEPEPETL() заинлайнится, то компилятор сможет доказать, что там нет сайд эффектов
                                                            если нет, то не сможет
                                                            Ответить
                                                            • понятно, иначе вдруг он каждый раз разное возвращает?
                                                              Ответить
                                                              • да
                                                                в постгресе такой правильный сорт функции называется stable
                                                                которая не портит базу и всегда будет возвращать одно и то же, если передать одни и те же аргументы и сохранять текущее состояние базы
                                                                Ответить
                                                                • такую петушню и кешировать можно, наверное: один раз посчитать, и не трогать по крайней мере до измененеия базы
                                                                  Ответить
                                                                  • да
                                                                    но самое главное, такую питушню можно использовать как критерий сортировки
                                                                    Ответить
                                                          • Да. 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?
        Ответить
        • А ты против раста?

          Переписать кусок ядра на не шибко стабильное и не очень популярное говно ради не однозначных преимуществ -- так себе идея, конечно.
          Ответить
        • Комьюнити у раста и го - это просто пиздец, да. Юные прыщефанатики, которые раньше пытались впарить линукс всем подряд. Идеология примерно та же - если у вас есть проблемы с нашим замечательным языком, то ваш юзкейс "нинужен".
          Ответить
          • По этому я за луа
            Ответить
          • А у «PHP» комьюнити просто заебись.
            Ответить
          • я помню что как-то на меня удивленно смотрели, когда я охуевше узнал, что у го дженериков нет и зависимости прямо в гит-репозитории хранятся, и немедленно об этом сообщил
            Ответить
            • > зависимости прямо в репозитории

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

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

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

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

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

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

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

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

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

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

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

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

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

                  Вон даже на ГК вбросы про "кресты говно" уже не вызывают эмоций.
                  Ответить
                  • Именно поэтому я за «С++».
                    Ответить
                  • остальные языки плодят дураков, а дураки счастливы, ибо не знают, как они несчастны
                    Ответить
                    • Именно поэтому я за «PHP».
                      Ответить
                      • да, именно так

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

                        Ну и какой язык лучше?
                        Ответить
                        • Лучше «Бейсик». На нём можно в горилл поиграть.
                          Ответить
    • 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.
      Ответить
      • >I'd actually like Rust to replace C
        ну я прямо вижу, как торвальдс переписывает ядро на раст ради борроу чекера
        Ответить
        • В ядрах, где многие структуры входят одновременно в 100500 циклических списков и деревьев, борроу чекер особенно актуален. Раст и с одним то циклическим списком не справится без ансейфа. Да и с джвунаправленным вроде тоже.
          Ответить
          • Когда я его последний раз трогал (много лет назад), он и на односвязном обсирался. Пытался деструктор (или что там у него) для cons-cells рекуррентно вызвать и пробивал дно стека.
            Ответить
            • понянтно

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

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

                  Именно поэтому единственная вменяемая структура данных — одномерный массив.
                  Ответить
      • > 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)
              Ответить
    • Го следует принципам изначальной жабы - максимально простой язык за который можно посадить необученную макаку без боязни, что она что-нибудь сломает. Только в отличие от жабы тут ещё и исключения, дженерики и ООП отпилили.
      Ответить
      • для тех, кто слишком туп даже для джавы?
        Ответить
        • даже для «PHP»
          Ответить
          • джависты все же умнее пыхеров, но не шибко
            Ответить
            • обижаешь
              Ответить
              • ты пыхер или джавист?
                Ответить
                • целуй node js!
                  Ответить
                  • https://www.znak.com/2020-09-08/v_chechne_pohitili_i_zastavili_sest_na_b utylku_moderatora_oppozicionnogo_chata
                    Ответить
                • к сожалению, да
                  Ответить
                  • Ну осознание проблемы это ведь первый шаг к избавлению!
                    Хочешь войти в настоящий, тревожный, волнующий мир крестов из душного мешка жабапараши, где ничего нельзя?
                    Ответить
      • Ну, а почему в "максимально простом языке" нельзя создать на лету JSON произвольной структуры сразу для отдачи клиенту? Это-то что может сломать?
        Ответить
        • Ну, а почему в "максимально простом языке" нельзя сразу послать сообщение в мессенджер "signal"? Это-то что может сломать?
          Ответить
      • Ого какое обсуждение в треде конарды. Уёбкам отвечать уже можно?
        Ответить
        • конардо это пол уебка, ему иногда можно отвечать
          Ответить
          • В целом, к баграм я уже охладел (вследствие чего и свалил отсюда на какое-то время).
            Ответить
          • Предлагаю так: на чётные комментарии не отвечать, на нечётные отвечать.
            Ответить
            • >на чётные комментарии не отвечать, на нечётные отвечать.
              https://govnokod.ru/26927#comment573150
              https://govnokod.xyz/_26927/#comment-557333


              Экое коварство. На ГК он чётный, а на хузе нечётный.

              И как теперь быть? Отвечать только на хузе? Но он всё-равно ответит и на ГК.
              Ответить
              • Ответ Шрёдингера - сломать синхронизатор и ответить только на одном из сайтов.
                Ответить
                • что будет, если я в одну миллисекунду исправлю свой коммент на разных сайтах?
                  Ответить
                  • Версия с хуза победит.

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

              мне он тоже малоприятен, но всё таки тут мы видим тупость, но не блевотню его обычную
              не?
              Ответить
              • https://gcode.space/#!/search?user=AnalPerOral

                > Заделал твой анус, проверь.
                > Пенисом.
                > Анал, минет, кордебалет.
                > Но член мой ты дружески можешь подержать.
                > А мой хуец тебе в глаза не бросился?
                > Засунул тебе вовнутрь, проверь.
                > Поюзал твой анус, проверь.
                > Встретил твою мамку с блядок.
                > Сунул свой кривой-перекривой хуец тебе в попец, проверь.
                > Увидел у тебя промеж ягодиц.
                > Дал тебе слизать спермач с моего хуя.

                Вот это не стертор?
                Ответить
              • смешались в кучу кони осетины
                Ответить
    • АДМИН СМОТРИТ ДОМ-2
      Ответить
    • АДМИН СМОТРИТ ДОМ-2
      Ответить
    • АДМИН СМОТРИТ ДОМ-2
      Ответить

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