На главную Наши проекты:
Журнал   ·   Discuz!ML   ·   Wiki   ·   DRKB   ·   Помощь проекту
ПРАВИЛА FAQ Помощь Участники Календарь Избранное RSS

Поздравляем всех студентов и Татьян с Татьяниным днём!




msm.ru
! Правила раздела:
1. Название темы - краткое описание кто/что против кого/чего
2. В первом сообщении - список параметров, по которым идет сравнение.
3. Старайтесь аргументировать свои высказывания. Фразы типа "Венда/Слюникс - ацтой" считаются флудом.
4. Давайте жить дружно и не доводить обсуждение до маразма и личных оскорблений.
Модераторы: Модераторы, Комодераторы
Страницы: (12) « Первая ... 9 10 [11] 12  все  ( Перейти к последнему сообщению )  
> Сохранение и восстановление состояния обработки
    Цитата korvin @
    Какие условия задачи? По-твоему, новый процесс куда добавляется? В вакуум? Чтобы что? Чтобы просто так висел в сторонке?

    ты поменял переходы для двух решений 2 и 4. И спрашиваешь - я ничего не менял. Я просто добавил процесс... Лол.


    Цитата korvin @
    Что же там отсебятина?

    Переделал сигнатуру метода например.

    Цитата korvin @
    Что же, по-твоему, означает «добавление нового процесса»?

    Это значит что ты добавляешь просто новый процесс, с новым решением. И все. Если ты начинаешь менять условия для уже существующих решений - это как не крути, называется изменение уже существующих условий и требований. Не? Ты же написал, что добавишь один процесс, и мне придется менять все свои классы. Так нет же. Если ты добавишь новый процесс, мне абсолютно ничего не придется менять.
    Если ты хочешь встроить свой процесс в уже существующую схему - то тебе при любых раскладах придется менять уже существующую схему, и изменения будут что у меня, что у тебя соответствующими, и никакие SOLID тут не причем.

    Цитата korvin @
    Изменение двух классов по одной причине.

    По какой одной причине? Ты во первых добавляешь 2 сущности(process, decision), во вторых ты сам меняешь уже существующий алгоритм работы схемы внося в него изменения. Еще раз, где тут нарушение SOLID ? Во первых у меня вообще никак не страдает общая архитектура от этих правок. Во вторых - если не хочешь менять то что уже существует, пожалуйста - создавай еще один класс наследник, реализуй его как тебе хочется. Это ты решил изменить условия задачи, и теперь пишешь про нарушения. Чувак я тебя не понимаю, ты несешь лютейшую дичь. А если завтра ты скажешь - а я хочу вообще выкинуть процессы, и решения, и вместо этой схемы просто будет дан массив чисел, и в зависимости от того, какое число в N-ом элементе, надо вызывать соответствующую функцию. Хватит нести херню.

    Мне уже реально надоело обсуждать этот бред.


    Цитата korvin @
    Я тебе схему привёл, код и diff. Указанные изменения есть? Есть.

    Ты поменял уже существующие условия , а не добавил новый процесс. Алё. Раз ты меняешь уже существующие условия - то ты так и пиши, если я изменю существующие условия, то тебе придется свои классы править. Только тогда это будет не аргумент, потому что тебе так же придется все твои сущности править. Ты же пишешь мне - я добавлю новый процесс и тебе придется классы править, при этом ты меняешь условия, правишь мои классы и правишь тоже самое у себя. Лол :crazy:

    Цитата korvin @
    Естественно. Ты не до конца прочитал мой пост, что ли?

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

    Цитата korvin @
    Это стрелки диаграммы, как они нарисованы на схеме, так они тут и написаны. Всё наглядно.

    Ничего там не наглядно, вот эта сопля - по факту считай как мой класс Decision. Просто у тебя оно реализовано что то типа тернарного оператора с элементами лямбды, с определенный синтаксисом. Но я твой код - даже и близко не обсуждал. Мне как бы твоя функциональщина нахер не упала. Птичий язык, и разбираться в нем у меня нет ни желания, ни времени. Я глянул твой дифф, что у тебя, что у меня менять будет примерно одинаково. Единственное что синтаксис разный.


    Цитата korvin @
    Ага. Только не менял какой-то там Process2DecisionHandler, хрен пойми, где находящийся. )

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

    Конкретно в этом случае - у тебя основной аргумент идет на то, что пример синтетический, и тебя толи напугали, то ли от своей тупости почему то оттолкнули классы. Но если бы вот этот каждый Decision/Process был не просто верни true/false, а что то более громоздкое, например какие то вычисления, занимающие с 10 строк, то я почему то уверен ты бы сам все это разнес бы по функциям/классам, а не лепил бы в одну строку соплей, которую ты выставляешь каким то ахеренным решением.

    Цитата korvin @
    Ещё раз перечитай последнее предложение:

    А что мне перечитывать? Ты же несешь очередной бред. У меня это все не запутаннее твоего, я бы даже сказал на порядок проще, потому что глядя на твои портянки на функциональщие, - там на самом деле вообще нихера не понятно. Идеальный спагетти-код какой то.
      Киля, я вот тут просто вынужден согласится с korvin. Хотя мы в "Политике" с ним ацки воюем, просто моря и окияны крови ... Тут я на его стороне! Твои эти си-шарпповские "прокладки" в программировании недетерминированных алгоритмов (которые решаются автоматной логикой) вообще не упали. Да, ты можешь сказать - у меня прекрасный "программный сахар". Ну и? Не соглашусь, его over дофика получается, ну просто over! Цени дальше ...

      Цитата Wound @
      Если ты начинаешь менять условия для уже существующих решений - это как не крути, называется изменение уже существующих условий и требований. Не?

      Никто ничего не менял существенно - изменили алгоритм путем вставки процесса. Што не таг? :blink:

      Напомню, если забылось... Начинали со сложных много-вложенных циклов с сохранением и восстановлением вычислений и уместности прекрасного оператора GOTO. Как я и ванговал в середине обсуждения - пришли к автоматным вычислениям. Только твоя реализация слишком "сладкая", до тошноты! Хватит таблицы переходов и обработчиков (ляммб, или функций, пофик). korvin предложил оптимизацию - не разделять "процессы" и "решения". И это, ящетаю, качественная модернизация подхода!

      Вангую ... наберешься злости и давай спорить. Только это уже никому не интересно :lol: А вот если запилишь на шарпах обычный автомат, без ООП и прочей шляпы - тебе не будет цены!!! Вааще цена будет - очень высокая.

      Скрытый текст
      Если ты все же желаешь продвигать свою ООП-шнягу - давай строками кода схлестнемся!!! >:(
      Сообщение отредактировано: Qraizer -
        Цитата Majestio @
        korvin предложил оптимизацию - не разделять "процессы" и "решения". И это, ящетаю, качественная модернизация подхода!

        Это даже оптимизацией-то не назвать. Ты же сам в своём первом примере объединил processN и decisionN в одну процедуру(функцию). Вот следующий шаг — вместо true/false возвращать сразу индекс процесса, который нужно запустить следующим. Можно сделать ещё один шаг: вместо индекса сразу возвращать указатель на следующую процедуру/функцию.

        Т.е. вместо, например,

        ExpandedWrap disabled
          func block1() State {
              process1()
              if decision1() {
                  return Proc4
              } else {
                  return Proc3
              }
          }
           
          for {
              switch state {
              case Proc1:
                  state = block1()
              case Proc2:
                  ...
              ...
              case Proc5:
                  return
              }
          }

        сделать так, избавившись от switch/case:
        ExpandedWrap disabled
          type Block func() Block
           
          func block1() Block {
              process1()
              if decision1() {
                  return block4
              } else {
                  return block3
              }
          }
           
          ...
           
          func block5() Block {
              ...
              return nil
          }
           
          ...
           
          var block = block1
           
          for block != nil {
              block = block()
          }

        Так немного теряется наглядность переходов от процесса к процессу, но тем не менее.

        Вот пример такого решения: https://youtu.be/HxaD_trXwRE?t=738
        Сообщение отредактировано: korvin -
          Цитата Majestio @
          Вангую ... наберешься злости и давай спорить.

          Мне вообще пофик. Я уже встречал таких, которые втирали что монолит это клево, и что вообще писать 100 000 строк кода в функции main - в этом ничего плохого нет. И не раз с ними спорил. И сейчас в очередной раз убедился, что до сих пор такие существуют. Ну ок. Пиши как хочешь. Хоть 300 лямбд создай. Вообще пофигу. Эту задачу, что ты предложил - много ума не надо, чтоб решить с помощью If/else, если бы так стоял вопрос - я бы даже не стал участвовать в этом говно-ивенте. Как то так.

          Дальше уж без меня тут сритесь, мне пока не интересно дальше рассуждать. Т.к. по делу претензий не было, от слова совсем.

          Добавлено
          Цитата Majestio @
          Если ты все же желаешь продвигать свою ООП-шнягу - давай строками кода схлестнемся!!! >:(

          Она не моя. Она общаяя. :-?

          Добавлено
          Цитата Majestio @
          Начинали со сложных много-вложенных циклов с сохранением и восстановлением вычислений и уместности прекрасного оператора GOTO.

          Да, и тут ты умудрился обосраться. Сначало заливал про свой goto, а на деле - даже не понял как его применять лол. Это как знаешь, поговорка есть - На словах ты Лев Толстой, а на деле Хрен морской... Вот это как раз про тебя и твой goto :D

          Добавлено
          Цитата korvin @
          Можно сделать ещё один шаг: вместо индекса сразу возвращать указатель на следующую процедуру/функцию.

          Это прям прогресс...

          Цитата korvin @
          Так немного теряется наглядность переходов от процесса к процессу, но тем не менее.

          Что то мне это напомнило... А да, ты же и задизил мое решение, которое выглядит именно так. Единственное что вместо указателя на следующую процедуру/функцию - у меня возвращается название класса.
          Ну ниче, еще немного глядишь на ООП перепишешь, получится нечто похожее на то, что я предложил.
          Сообщение отредактировано: Qraizer -
            Цитата Wound @
            и что вообще писать 100 000 строк кода в функции main - в этом ничего плохого нет.

            А что в этом плохого, если ты реально хорошо пишешь? Можно же и на С# наговнокодить на четыре сортира. Что плохого в большом и качественном коде в функции main?
              Цитата Wound @
              писать 100 000 строк кода в функции main - в этом ничего плохого нет.

              Зачем писать 100 000 строк в main?
                Цитата Majestio @
                А что в этом плохого, если ты реально хорошо пишешь? Можно же и на С# наговнокодить на четыре сортира. Что плохого в большом и качественном коде в функции main?

                Гхм, ну судя по всему, с твоей точки зрения ничего плохого в этом нет...

                Цитата korvin @
                Зачем писать 100 000 строк в main?

                Как выше спросил Majestio, а что в этом плохого? Адресуй этот вопрос ему, потому что у меня нет ответа на этот вопрос, и я тоже задавал адептам такого подхода - похожий вопрос. Уж не помню суть ответов, давно это было. :-?

                Добавлено
                Цитата Majestio @
                Ну и? Не соглашусь, его over дохуя получается, ну просто over! Цени дальше ...

                Что в твоей задаче подразумевалось под процессами? Только вот эти школьные сложить/умножить/поделить? Возьми реальный процесс, программу, который(процесс) в винде создается функцией CreateProcess например. Как ты это на свои лямбды переведешь, монолитом в функции main, расскажешь? (не, я абсолюнто уверен что это сделать не проблема, если что, не надо мне доказывать что это якобы реально)

                Или у тебя все задачи такого уровня, что ты привел?

                Добавлено
                Цитата Majestio @
                Никто ничего не менял существенно - изменили алгоритм путем вставки процесса. Што не таг? :blink:

                Все так. Просто я не знаю как там korvin, лично я доказывал что тебе/ему/мне - надо сделать одно и тоже. Только выглядеть это будет по разному. Тебе условия поменять, ему соплю поправить, мне реализацию метода в классе изменить.
                Речь шла не об этом. Он докопался до SOLID, якобы при изменении реализации метода класса я его нарушаю, но на самом деле - в этом конкретном случае, с моей точки зрения - нет нарушения SOLID. Но откуда тебе про это знать то, если ты оперируешь goto и пишешь проги в main ?
                Ты просто не понял о чем мы спорили.

                Добавлено
                Цитата Majestio @
                korvin предложил оптимизацию - не разделять "процессы" и "решения".

                Да ладно? А что он предложил, ты сам то понял? Это то что ниже твоего поста - он примером показал? Рили? Ну нихера себе оптимизация... Ты сам то понимаешь что он предлагает? Или просто поддакиваешь?
                Сообщение отредактировано: Qraizer -
                  Цитата Wound @
                  Только вот эти школьные сложить/умножить/поделить? Возьми реальный процесс, программу, который(процесс) в винде создается функцией CreateProcess например.

                  Чтобы он в отдельном процессе вывел окошко с кнопкой Акей? Это верх программной логики :lol: А то, что существуют программы именно математических пересчетов, тебе точно не ведомо? Да, там отдельные операции чисто математические, ну что тут поделаешь.

                  Цитата Wound @
                  с моей точки зрения - нет нарушения SOLID

                  В том то и дело, что это с твоей точки зрения. Нарушаешь и не сознаешься в грехе! Не солидно получается :(

                  Цитата Wound @
                  Это то что ниже твоего поста - он примером показал? Рили? Ну нихера себе оптимизация... Ты сам то понимаешь что он предлагает? Или просто поддакиваешь?

                  Похоже на провок. Не понимаешь и пытаешься меня спровоцировать на объяснение. Ну ладно - расскажу, если тебе лениво самому разобраться. В последних обсуждениях я задал вопросы, что делать если в алгоритме появляются безусловные переходы между процессами, или множественные (а-ля) switch-case "решения". Так вот, в моем случае, когда процессы и решения разделены - это можно решать с помощью "процессов-заглушек", либо "решений-заглушек", т.к. у меня идет попарный вызов -"процесс-решение". В его же предложении есть хорошее зерно - объединить все вызовы в единую таблицу. Где все вызовы делаются вне зависимости от типа вызываемой функции или лямбды. И это сразу же избавляет от необходимости введения этих самых "заглушек". Код чище и оптимальнее.

                  Кстати, когда будешь использовать GOTO из главной функции main прямо в тело другой функции - не забудь поправить стек! Иначе по выходу из функции полетит память, и не сможешь вывести кнопку Акей! :whistle: Хотя ... ты же на сишарпе кодишь - вам там вообще нельзя с железными регистрами проца и памятью работать напрямую. Или можно?

                  Кстати, стадию отрицания оператора GOTO можно быстрее и успешнее пережить - посетив всего пару курсов экстремального быдлокодинга на бейсеке 8-)
                    Цитата Majestio @
                    Чтобы он в отдельном процессе вывел окошко с кнопкой Акей? Это верх программной логики :lol: А то, что существуют программы именно математических пересчетов, тебе точно не ведомо? Да, там отдельные операции чисто математические, ну что тут поделаешь.

                    Нет. Я тебе пытаюсь донести что в твоем случае - сам процесс какая то высосаная из пальца однострочная фиговина. Представь что процесс - это целая программа.


                    Цитата Majestio @
                    Похоже на провок. Не понимаешь и пытаешься меня спровоцировать на объяснение. Ну ладно - расскажу, если тебе лениво самому разобраться. В последних обсуждениях я задал вопросы, что делать если в алгоритме появляются безусловные переходы между процессами, или множественные (а-ля) switch-case "решения". Так вот, в моем случае, когда процессы и решения разделены - это можно решать с помощью "процессов-заглушек", либо "решений-заглушек", т.к. у меня идет попарный вызов -"процесс-решение". В его же предложении есть хорошее зерно - объединить все вызовы в единую таблицу. Где все вызовы делаются вне зависимости от типа вызываемой функции или лямбды. И это сразу же избавляет от необходимости введения этих самых "заглушек". Код чище и оптимальнее.

                    Если ты внимательно посмотришь на его пример, и в мой код Handler'ов, и там где они вызываются, то возможно увидишь схожесть...
                      Цитата Wound @
                      Нет. Я тебе пытаюсь донести что в твоем случае - сам процесс какая то высосаная из пальца однострочная фиговина. Представь что процесс - это целая программа.

                      Вот ты и попался, который кусался! :lool: Запомни, с твоим таким подходом - нельзя полноценно остановить, запомнить состояние. А потом возобновить. Любые процессы длинною в жысть нужно дробить на мелкие. Вот тогда и только тогда у тебя появится возможность приостановления и сохранения состояния оперативно. Ну и возобновления. Андестенд?

                      Цитата Wound @
                      Если ты внимательно посмотришь на его пример, и в мой код Handler'ов, и там где они вызываются, то возможно увидишь схожесть...

                      Просто в твоем коде овер дохера букв, а у него нет. Ну х3, но если оно так - ну чо, респект ему и тебе. А мне нет.
                        Цитата Majestio @
                        Кстати, стадию отрицания оператора GOTO можно быстрее и успешнее пережить - посетив всего пару курсов экстремального быдлокодинга на бейсеке
                        Ну... зачем так сурово-то. Гораздо интереснее скриптовать на CMD. Самый мощный мой скрипт размером 64К был. Там сборка в трёх конфигурациях, две из которых инструментирующие, модульных тестов для 47 различных функциональностей и их прогон с генерированием отчётов под 8-ю разными (не x86 даже близко) процессорами на стендах с использованием 8-и же разных сред разработки. Параметры сборки в частности определялись ещё и парсингом текста тестов, исполнительное тестовое окружение могло быть тоже 3-х разных версий и до кучи есть несколько исключений и правил, прописанных опять же в стороннем файле, который тоже нужно было парсить. И всё это в параллель, но одновременно не более чем количество ядер у процессора + количество подключённых стендов. Как я семафор для ограничения параллельных сборок писал, это отдельный экзерсис. Вот где goto во всей красе, без него даже циклы нормально написать зачастую невозможно.

                        Добавлено
                        Вот для примера определение номера партиции (некоторые тесты из-за размера приходилось бить на части) теста в его ID.
                        ExpandedWrap disabled
                          rem /**************************************************\
                          rem |        Получить номер парта из ID теста,         |
                          rem |                   если он есть                   |
                          rem \**************************************************/
                          :getPartNumber
                          setlocal
                          set testName=%1
                          rem проверить наличие деления теста на парты
                          if "%testName%" EQU "%testName:_PART_=%" (endlocal & set result= & exit /b)
                          set res=
                          rem найти номер парта в ID теста
                          :scanPart
                          rem разделители частей _ и .
                          for /f "tokens=1,* delims=_." %%x in ("%testName%") do (
                            rem отсеять предшествующие части ID
                            if "%%x" == "PART" (
                              rem номер парта будет следующей частью
                              for /f "tokens=1,2 delims=_." %%y in ("%testName%") do set res=%%z
                            ) else (
                              rem удалить начало ID из него
                              set testName=%%y
                              goto scanPart
                            )
                          )
                          rem номер найден
                          endlocal & set result=_PART_%res%
                          exit /b
                        Сообщение отредактировано: Qraizer -
                          Цитата Qraizer @
                          Вот где goto во всей красе, без него даже циклы нормально написать зачастую невозможно.

                          По красоте. Да здравствует прекрасный оператор GOTO!!! :victory:
                            Кстати ... для оформления комментов в CMD-скриптах рекомендую использовать вместо REM пару двоеточий, смотрится красивше.

                            Вот пример:

                            ExpandedWrap disabled
                              ::
                              :: ┌───────────────────────────────────────────────────────────────────────────┐
                              :: │       Получить номер парта из ID теста,                                   │
                              :: │                  если он есть                                             │░░
                              :: └───────────────────────────────────────────────────────────────────────────┘░░
                              ::   ░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░░
                               
                              :getPartNumber
                              setlocal
                              set testName=%1
                              rem проверить наличие деления теста на парты
                              if "%testName%" EQU "%testName:_PART_=%" (endlocal & set result= & exit /b)
                              set res=
                              rem найти номер парта в ID теста
                              :scanPart
                              rem разделители частей _ и .
                              for /f "tokens=1,* delims=_." %%x in ("%testName%") do (
                               rem отсеять предшествующие части ID
                               if "%%x" == "PART" (
                                 rem номер парта будет следующей частью
                                 for /f "tokens=1,2 delims=_." %%y in ("%testName%") do set res=%%z
                                ) else (
                                 rem удалить начало ID из него
                                 set testName=%%y
                                  goto scanPart
                                )
                              )
                              rem номер найден
                              endlocal & set result=_PART_%res%
                              exit /b
                              Цитата Majestio @
                              Вот ты и попался, который кусался! :lool: Запомни, с твоим таким подходом - нельзя полноценно остановить, запомнить состояние. А потом возобновить. Любые процессы длинною в жысть нужно дробить на мелкие. Вот тогда и только тогда у тебя появится возможность приостановления и сохранения состояния оперативно. Ну и возобновления. Андестенд?

                              Если честно - ничего не понял :-?

                              Цитата Majestio @
                              Просто в твоем коде овер дохера букв, а у него нет. Ну х3, но если оно так - ну чо, респект ему и тебе. А мне нет.

                              А ты не на буквы смотри, а на контекст(суть программы, а не строчки считай).
                                Цитата Qraizer @
                                Вот для примера определение номера партиции (некоторые тесты из-за размера приходилось бить на части) теста в его ID.

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

                                Давайте приводите что то более существенное.
                                Сообщение отредактировано: Wound -
                                0 пользователей читают эту тему (0 гостей и 0 скрытых пользователей)
                                0 пользователей:


                                Рейтинг@Mail.ru
                                [ Script execution time: 0,0883 ]   [ 15 queries used ]   [ Generated: 27.01.23, 02:37 GMT ]