1. C++ / Говнокод #23449

    0

    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
    28. 28
    29. 29
    30. 30
    31. 31
    32. 32
    33. 33
    34. 34
    35. 35
    36. 36
    37. 37
    38. 38
    39. 39
    40. 40
    41. 41
    42. 42
    43. 43
    44. 44
    45. 45
    46. 46
    47. 47
    48. 48
    49. 49
    50. 50
    51. 51
    52. 52
    53. 53
    54. 54
    https://github.com/TartanLlama/optional/blob/master/optional.hpp#L853
    
      /// Constructs the stored value with `u`.
      /// \synopsis template <class U=T> constexpr optional(U &&u);
      template <
          class U = T,
          detail::enable_if_t<std::is_convertible<U &&, T>::value> * = nullptr,
          detail::enable_forward_value<T, U> * = nullptr>
      constexpr optional(U &&u) : base(in_place, std::forward<U>(u)) {}
    
      /// \exclude
      template <
          class U = T,
          detail::enable_if_t<!std::is_convertible<U &&, T>::value> * = nullptr,
          detail::enable_forward_value<T, U> * = nullptr>
      constexpr explicit optional(U &&u) : base(in_place, std::forward<U>(u)) {}
    
      /// Converting copy constructor.
      /// \synopsis template <class U> optional(const optional<U> &rhs);
      template <
          class U, detail::enable_from_other<T, U, const U &> * = nullptr,
          detail::enable_if_t<std::is_convertible<const U &, T>::value> * = nullptr>
      optional(const optional<U> &rhs) {
        this->m_has_value = true;
        new (std::addressof(this->m_value)) T(*rhs);
      }
    
      /// \exclude
      template <class U, detail::enable_from_other<T, U, const U &> * = nullptr,
                detail::enable_if_t<!std::is_convertible<const U &, T>::value> * =
                    nullptr>
      explicit optional(const optional<U> &rhs) {
        this->m_has_value = true;
        new (std::addressof(this->m_value)) T(*rhs);
      }
    
      /// Converting move constructor.
      /// \synopsis template <class U> optional(optional<U> &&rhs);
      template <
          class U, detail::enable_from_other<T, U, U &&> * = nullptr,
          detail::enable_if_t<std::is_convertible<U &&, T>::value> * = nullptr>
      optional(optional<U> &&rhs) {
        this->m_has_value = true;
        new (std::addressof(this->m_value)) T(std::move(*rhs));
      }
    
      /// \exclude
      template <
          class U, detail::enable_from_other<T, U, U &&> * = nullptr,
          detail::enable_if_t<!std::is_convertible<U &&, T>::value> * = nullptr>
      explicit optional(optional<U> &&rhs) {
        this->m_has_value = true;
        new (std::addressof(this->m_value)) T(std::move(*rhs));
      }

    Я даже не знаю, какой конкретно фрагмент этого творчества сюда выкладывать.

    https://github.com/TartanLlama/optional C++11/14/17 std::optional with functional-style extensions https://optional.tartanllama.xyz

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

    Понятно что из плюсов никакого гомоиконного лиспа сделать не выйдет, ведь тогда надо выкинуть очень красивый и элегантный плюсосинтаксис вида std::kukarek(std:kudah<std:kokoko{kokoko ko[hui<govno>]}>:()[*huita]{}) и заменить его на бездуховные скобочки

    Запостил: j123123, 24 Октября 2017

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

    • -- Знаете, мы раньше кушали Си, но потом узнали что в нем мало профита. И тогда мы изобрели С++ со вкусом Си, и кушаем его.
      -- А почему со вкусом Си? Может быть можно было со вкусом C#?
      -- C#? А что, можно было?
      Ответить
      • Когда изобретали C++, никакого C# не было
        Ответить
        • # никакого C# не было

          Надо было подождать
          Ответить
          • оборачивай глупости в зеленый чтобы все думали что ты сарказмируешь, а не взаправду глупый
            Ответить
            • # взаправду глупый

              Как же ТАКОЕ могло случиться со мной?!
              Ответить
    • https://github.com/ned14/outcome/blob/boost_peer_review3/include/boost/outcome/v1.0/monad.hpp
      https://github.com/ned14/outcome/blob/boost_peer_review3/include/boost/outcome/v1.0/detail/basic_monad.ipp
      Раз уж подняли эту тему, вот памятник метушиного искусства, который выглядит странно даже по крестоблядским меркам - помимо обычной крестометушни там еще кодогенерация через определение макросов и инклуд "шаблона". Это реализация утилитарного класса наподобие optional. Автор пытался пропихнуть это в буст, но его зачморили, и он с подгоревшей жопой убежал все переписывать. Вообще история отношений nial'а и буста очень грустная и преисполнена батхерта. Странный он парень.
      Свежие ревизии этой библиотеки тоже можно почитать, но там все не так прикольно, обычная крестоебля.
      Ответить
    • optional(const optional<U> &rhs) {
          this->m_has_value = true;
          new (std::addressof(this->m_value)) T(*rhs);
        }

      Вспомнилась байка про старца в комитете с++, который всё время спал а потом посреди доклада говорил "А тут бах и исключение!"

      > Сделайте там уже возможность в компилтайме работать напрямую с исходным кодом самого себя

      Саттер метаклассы продвигает, не оно? Или тебе нужен говнокодогенератор, но внутри языка?
      Ответить
      • > Или тебе нужен говнокодогенератор, но внутри языка?

        Именно! Ведь тогда можно не допиливать каждый раз все компиляторы под новые говнофичи плюсов при выходе нового стандарта, а все эти говнофичи реализовывать через этот самый говнокодогенератор. Можно будет даже новые операторы и ключевые слова добавлять при желании, весь код перед обычной компиляцией может сколько угодно раз пропускаться через особую кодогенерирующую плюсовую метушню(старая метушня может сгенерировать новую метушню, через которую весь код опять будет пропускаться), которая бы добавляла в плюсы какие-нибудь новые хрени, типа всяких там лямбд-хуямбд, т.е. чтоб можно было бы даже синтаксис РАСШИРИТЬ, добавив например каких-нибудь триграфов, которые в C++17 собираются убрать
        Ответить
        • А то вот всякие std::constexpr_vector придумывают https://youtu.be/FcCymlVAtP8?t=3130 - нахрена? Возьмите уже кодогенерацию и не мучайте жопу
          Ответить
        • # РАСШИРИТЬ

          * g o a t s e x * g o a t s e x * g o a t s e x *
          g                                               g  
          o /     \             \            /    \       o
          a|       |             \          |      |      a
          t|       `.             |         |       :     t
          s`        |             |        \|       |     s
          e \       | /       /  \\\   --__ \\       :    e
          x  \      \/   _--~~          ~--__| \     |    x  
          *   \      \_-~                    ~-_\    |    *
          g    \_     \        _.--------.______\|   |    g
          o      \     \______// _ ___ _ (_(__>  \   |    o
          a       \   .  C ___)  ______ (_(____>  |  /    a
          t       /\ |   C ____)/      \ (_____>  |_/     t
          s      / /\|   C_____)       |  (___>   /  \    s
          e     |   (   _C_____)\______/  // _/ /     \   e
          x     |    \  |__   \\_________// (__/       |  x
          *    | \    \____)   `----   --'             |  *
          g    |  \_          ___\       /_          _/ | g
          o   |              /    |     |  \            | o
          a   |             |    /       \  \           | a
          t   |          / /    |         |  \           |t
          s   |         / /      \__/\___/    |          |s
          e  |           /        |    |       |         |e
          x  |          |         |    |       |         |x
          * g o a t s e x * g o a t s e x * g o a t s e x *
          Ответить
        • Кстати вот в перле https://perldoc.perl.org/perlfilter.html
          Ответить
        • итого реализовать любой шаблонный класс будет так же тривиально просто, как и реализовать его нативную поддержку в компиляторе. Но круче всего когда вместо T в шаблоне используется какой-нибудь {%Type}. А самая крутотенюшка - указывать явно компилятору, какой код генерировать. Ведь type deduction guides это говнометушня, куда лучше писать свой парсер языка чтобы получить поведение vector v = {1,2,3}; И как комитет до этого не додумался?

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

                Для розыгрыша тританопов (более редкая патология, обычно приобретается, если долго смотреть на сварку) нужно сочетание чёрного с синим.
                Ответить
                • Маловато цветов. Надо какую-то более глобальную проверку устроить:

                  синий текст
                  зелёный текст
                  красный текст
                  чёрный текст
                  жёлтый текст
                  Ответить
                  • тест_финской_армии.jpg
                    Ответить
                  • Старожилы Говнокода знают, что тут нет тега для жёлтого текста, поэтому даже будучи дальтониками заподозрят неладное.
                    Ответить
                    • Откуда у них такая уверенность в отсутствии тега для жёлтого текста? Страйкер вполне мог самостоятельно вычислить отдельные категории дальтоников и отключить для них жёлтый тег, чтобы не оскорблять их чувства. И чтобы они не догадались, проделал это для их IP адресов, характерных user-agentов, разрешений экрана, наборов плагинов, паттернов движения мыши.
                      Ответить
                    • Неужели даже Вы не различаете оттенки жёлтого?
                      Ответить
          • > итого реализовать любой шаблонный класс будет так же тривиально просто, как и реализовать его нативную поддержку в компиляторе.

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

            > Ведь type deduction guides это говнометушня, куда лучше писать свой парсер языка чтобы получить поведение vector v = {1,2,3}; И как комитет до этого не додумался?

            Этот ваш плюсовый type deduction - говно. Например, есть такая штука, как типизация по Хиндли-Милнеру, зависимые типы. Когда такое в плюсах сделают? Этот ваш плюсовый говнокомитет только и умеет, что какие-то кривые костыли сбоку привинчивать ржавыми болтами
            Ответить
        • Да нa тебе, успокойся уже
          https://dlang.org/mixin.html
          Ответить
          • Только в плюсах этого нет
            Ответить
            • > Только в плюсах этого нет

              А тебе какая разница? Ты же всё равно на плюсах не пишешь.
              Ответить
              • Тогда зачем мне это показывать? На D я ведь тоже не пишу
                Ответить
        • Главное - ввести преобразования AST. Так, чтобы указал, в какое место грамматики вставляется изменение, и как оно обрабатывается - и всё. А не абстрактные генереции.
          Ответить
          • сделать базовый основной синтаксис как в лиспе, через скобочки, стандартизированный AST. И потом пилить всякие библиотеки времени компиляции, которые бы перегоняли другие синтаксисы в AST
            Ответить
            • https://www.tiobe.com/tiobe-index/
              Ответить
              • Инетерсный рейтинг
                Неужели на асме правда пишут больше чем на swift?
                Ответить
          • аспекты?

            мне напомнило про вот это:
            http://seed7.sourceforge.net/manual/syntax.htm#The_syntax_of_a_statement

            но я думаю что таких "макросов" в крестах мы еще долго не увидим, потому что не метушня.
            Ответить
            • > аспекты?
              Не очень хорошо знаю аспекты. Насколько я понимаю, это инструмент для вставки кода в нужные места согласно описанным условиям.
              Если так, то расширить функционал и языка получится (например, встроить проверку границ в сишные массивы?), а синтаксис изменить - нет.

              > ssed7
              > Seed7, on the other hand, additionally allows user defined constructs
              > The definition of the 'loop' function (semantic definition of the loop-statement) is:
              Глянул ссылку. Целиком не прочитал, но на первый взгляд похоже на то, что я хочу.
              Надо повнимательней посмотреть будет. Интересно, как там обрабатывается заматченная циклическая и рекурсивная питушня (например, даже обычная регулярка /(?:([a-z])+:([a-z])+;)+/ на строке "a:b;ccc:dd;zzz:zzw" в идеале должна породить иерархический вывод [[['a'],['b']],[['c','c','c'],['d','d']],[['z','z','z'],['z','z','w']]], но мы увидим только ['z','w'] в популярных реализациях)
              Ответить
              • > Интересно, как там обрабатывается заматченная циклическая и рекурсивная питушня

                хез. какой-то пасквилянт уже много лет это дело неустанно пилит (да, это буквально one man project). раньше чисто интерпретировался язык - теперь вроде на llvm пытаются посадить. я одним глазом поглядываю - потому что эти "макросы" весьма привлекательная фича. как именно эти макросы выжывают вложенность я не в курсе (но логично было бы ожидать что будут работать, а то иначе - говно).

                > но мы увидим только ['z','w'] в популярных реализациях

                новые регулярки только матчат рекурсивно (ака бэктрекинг) - капче группы всегда были статическими. иначе же ты их не пронумеруешь (sed/perl/etc - \1, \2, этц), тебе понадобится какое подобие xpath'а для этого. и это сложно.
                Ответить
    • Поебанулись на своей метушне уже?
      Ответить
    • Развитие современных плюсов напоминает замазывание говном дырок в гнилой тонущей лодке. Например, были плюсы с шаблонами, но шаблоны это отдельная функционально-рекурсивная херня, обычный плюсовый код использовать в них нельзя. Придумали констэспры с кучей ограничений (тоже какая-то питушня, никаких тебе new/delete и даже циклов нихера нет, ебись рекурсивно). Потом в C+14 в constexpr добавляют поддержку всяких там циклов (goto только не поддерживается, как и всякие new delete malloc и проч., иными словами как было говно, так и осталось)
      https://isocpp.org/wiki/faq/cpp14-language#extended-constexpr
      Потом кто-то выдвигает гениальную идею сделать std::constexpr_vector https://youtu.be/FcCymlVAtP8?t=3130
      Потом они захотят многопоточность в компилтайме, и файлы читать в компилтайме, и вообще чтоб в компилтайме оно еще и отсасывать программисту могло (хотя оно и так сосет, образно).
      Ответить
      • Возникает логичный вопрос к неуважаемому комитету стандартизации говноплюсов - а не охуели ли вы? Нахера? Какого хера вы вообще творите, сделайте блядь новый язык, без этих кривых уёбищных костылей. А этот блядский кусок кривого говна пусть идет на дно, хватит замазывать дыры говном. Это кривое говнопорождение из 80 годов прошлого века, эволюционировавшее из препроцессора для сишки, вы не ебанулись ли?
        Ответить
        • сомневаюсь что представители комитета сидят на гк.

          Впрочем, что тебе мешает самому себе сделать новый язык? Если ты такой мировой эксперт и прекрасно знаешь каким идеальный яп должен быть?
          Ответить
        • > Нахера?

          (1) потому что могут.

          (2) потому что это опциональные фичи которые тебя никто не заставляет использовавать.

          (3) потому что добавляются в язык посредствов стандартной библиотеки, не ломая обратной совместимости.
          Ответить
          • > (2) потому что это опциональные фичи которые тебя никто не заставляет использовавать.

            Всё немного не так.
            1. Говностандартизаторы добавляют в плюсы очередную говнофичу
            2. Какие-то говнокодеры пишут говнокод с использованием говнофичи и выкладывают его в опенсорс
            3. Программист Вася использует программу, написанную говнокодерами, в котором используется говнофича
            3.1. Программист Вася сталкивается с необходимостью что-то в программе поменять, дабы адаптировать под свои потребности, или пофиксить баги
            3.2. Программист Вася вынужден разбираться с говнофичей, придуманной плюсовыми говностандартизаторами, т.к. говнокод написан с использованием данной говнофичи, и выбора у него нет.

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

              понимаю аргумент.

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

              тот же Duff's Device в ц трендом не стал - точно так же крестовая метушня после хайпа выродится в н-ное количество обычных простых примочек.

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

              поэтому то я лично (1) спокойно игнорирую метушню, (2) за будущее человечества не волнуюсь.
              Ответить
              • > после хайпа
                Лол. Уже 15 лет хайп. Когда же уже выродится?
                Ответить
                • хайп о метушне относительно недавно начался - когда разрешили рекурсию в темплейтах и добавили вариадик темплейты.

                  15 лет назад - народ еще мучался банальным хаосом разных несовместимых версий STL и кривой поддержкой оных в компилерах.
                  Ответить
                  • Че за рекурсия в темплейтах?
                    Книжка александреску появилась в 2001, буст мпл появился в первой половине нулевых - все тогда было уже.
                    Ответить
                    • > Че за рекурсия в темплейтах?

                      темплейт сам себя использует.

                      раньше тоже можно было, но было не практично из-за ограничений с++03.

                      в новых версиях ограничения убрали, и добавили вариадики. теперь это стало практично.
                      Ответить
                      • о каких ограничениях речь?
                        Ответить
                        • всего уже не помню. самое большое это было ограничения на авто-детект параметра типа темплейтах. плюс template < template <x,y> a > не работало.
                          Ответить
                          • в смысле не работало?
                            вот это? http://coliru.stacked-crooked.com/a/d17f23ad814e965fp
                            другой вопрос - нахуя
                            Ответить
                            • (1) линк не работает.
                              (2) ты спрашиваешь меня о коде 10-ти летней давности который жил ~1 день, и был викинут потому что либо не компилировалось, либо был verbose до бесполезности.

                              я тут один только что ли помню старые кошмары когда авто-выведение типов было никакое?
                              Ответить
                              • Да мы тут дебилы 15-летние, тогда только в школу пошли. Спроси баропа, может он помнит.
                                Ответить
                              • > когда авто-выведение типов было никакое?

                                Авто-выведение по стандарту или в твоём компиляторе от ВасянИнкорпорэйтед? Как авто-выведение в шаблонах изменилось с C++98 (кроме добавления вариадиков, разумеется)? Вроде мало серьёзных изменений до C++17
                                http://en.cppreference.com/w/cpp/language/template_argument_deduction
                                Ответить
                                • хез. вот только недавно писал прокладку на темплейтах. код тривиальный - с виду с++03. попробовал скомпилить - нифига не компилилось пока с++11 не включил. что-то там поменялось.
                                  Ответить
                                  • Очень мощная экспертиза.
                                    Ответить
                                  • лучше приходи с примерами

                                    с++ программисты имеют странную тенденцию даже не читать сообщения об ошибках. Они беспомощно смотрят на стену текста и говорят себе "а, ну значит так нельзя".
                                    Ответить
                                    • да, потому что, я гуглом и SO пользоватся не умею.
                                      Ответить
                                    • со временем учишься понимать какое именно из 10+ диагностических сообщений возникло в твоем коде, переходишь к нему а дальше либо угадал в чем проблема, либо нет
                                      Ответить
                                    • > не читать сообщения
                                      Потому что обычно лень читать эту стену из мусора и мыслей конпелятора...
                                      Ответить
                                      • обычно не так много. Сообщений 7-10, из которых беглое чтение может дать понять в чем именно проблема (обычно она там, куда указывает последнее)

                                        Вот помнится писал на конфе "лабу" на ranges, так там прога на 20 строк компилилась пару минут и в случае если что-то не так выдавала 100+ строк кода. И это при том, что ошибку ловил static_assert. Ждем концепты
                                        Ответить
                                        • > прога на 20 строк компилилась пару минут и в случае если что-то не так выдавала 100+ строк кода
                                          > ошибку ловил static_assert
                                          > Ждем концепты
                                          Необучаемые крестобляди.
                                          Ответить
                                          • уж лучше так, чем читать 1000+ строк пользовательского краш дампа
                                            Ответить
                                            • > 1000+ строк пользовательского краш дампа
                                              Откуда строки в крешдампе? Там же гигабайтики из оперативки...
                                              Ответить
            • программисту Васе платят зарплату за то, чтобы он поддерживал код. Если программист Вася в силу проф. некомпетентности не может или не хочет поддерживать код - пусть ищет др. работу
              Ответить
              • городить огороды и потом возмущатся что все слишком тупые - как раз это и не профессионально. сверх профессионально.

                ты так высокомерно говоришь наверное потому что ты еще монументальных факапов не видел, и на тебя не вешали ответственности их "до конца недели" газгребать. через пару раз начинаешь понимать почему 100 строчек тупого кода лучше 10 строчек умного.
                Ответить
                • Он так высокомерно говорит, потому что вызубрил метушню вместо матана и теперь думает, что неебаца компьютер сайнтист.
                  Ответить
                • > ты так высокомерно говоришь наверное потому что ты еще монументальных факапов

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

                  И вот что я скажу: если STL предоставляет мне инструмент, идеально подходящий для выполнения той или иной задачи, я воспользуюсь им не задумываясь. И не потому, что "читать 10 строк сложного кода проще чем 100 простого" или наоборот. А потому, что в отличие от костыльных самоделок, на STL есть отличная документация и в нем нет багов. Не знаешь что делает std::whatever? Идешь на en.cppreference.com (кстати, его доку можно и в ide встроить). Не знаешь что делает вон тот трехмерный цикл с 15-ю переменными? Идешь читать/на хуй/пить/бить морду автору (нужное подчеркнуть). Но самая большая разница в другом. Увидев std::whatever, использованный по другому, я сразу буду знать что он делает. А вот увидев новый трехмерный цикл с 15-ю переменными что делать будешь? Разбираться с нуля. И самое главное: в случае ошибки лаконичный код легче понять, чем переписать с нуля.
                  Ответить
                  • причем STL к метушне?

                    > А вот увидев новый трехмерный цикл с 15-ю переменными что делать будешь?

                    это не тупой код - это убогий и/или кривой код.

                    > лаконичный код легче понять

                    ты называешь метушню лаконичной?..

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

                    > У нас прекратили поддержку двух проектов из-за того, что вместо десятков строк умного кода лепили сотни тупого [...]

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

                    если бы ты стоял у истоков проекта - у тебя бы хватило смелости взять на себя ответственность сделать "умно"? и самое главное: хватило бы у тебя совести проект до конца довести после того как "умное" облажалось?

                    если код убогий - но концепция правильная - то выровнять это часто пара дней/недель с регулярками в виме. но если у тебя там концепция кривая - или она в принципе из-за требований пользователей нераспрямляемая - то тогда умный код тебе будет только мешать. потому что в 10 строк умного кода встявить костыль на порядки сложнее - чем вставить костыль в 100 строк тупого кода.
                    Ответить
                    • > а ты уверен что там десятком/сотней строк обошлось бы

                      Как правило код худеет в 2-3 раза. Бывало что в10.
                      Ответить
                  • >> У нас прекратили поддержку двух проектов из-за того, что вместо десятков строк умного кода лепили сотни тупог

                    А зачем выдумывать что-то сложное?
                    Надо просто взять, и вписать еще один if в тридцать семь мест. Разве сложно?
                    Ответить
                  • И меня вела дорога метушни... Потом я написал парсер YAML на boost::spirit и спустя короткое время решил его доработать. Компиляция упала с ошибкой длиной в тысячу строк, я посмотрел на это, плюнул и изучил борщеязыки.
                    Ответить
    • Сколько нужно крестушков, что бы вкрутить лампочку?
      Ответить
      • на этапе конпиляции
        Ответить
        • на этапе конпиляции как раз одного достаточно: включаешь конпиляцию Буста и идёшь подрабатывать электриком. К концу смены, глядишь, компиляция уже закончится.
          Ответить

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