Форум на Исходниках.RU

Сохранение и восстановление состояния обработки

Qraizer — Sat, 01 Oct 2022 10:48:17 +0000

Qraizer:

Цитата Wound @ 30.09.22, 21:04

Если это единственное оправданное применение goto - то как то не убедительно выглядит.

Оправданием служит то, что командный язык CMD ...как бы так помягче... эзотерический.

Сохранение и восстановление состояния обработки

Wound — Fri, 30 Sep 2022 21:04:52 +0000

Wound:

Цитата Qraizer @ 25.09.22, 13:05

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

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

Давайте приводите что то более существенное.

Сохранение и восстановление состояния обработки

Wound — Fri, 30 Sep 2022 19:53:24 +0000

Wound:

Цитата Majestio @ 25.09.22, 10:29

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

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

Цитата Majestio @ 25.09.22, 10:29

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

А ты не на буквы смотри, а на контекст(суть программы, а не строчки считай).

Сохранение и восстановление состояния обработки

Majestio — Sun, 25 Sep 2022 14:53:29 +0000

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

Вот пример:

:: ┌───────────────────────────────────────────────────────────────────────────┐

:: │ Получить номер парта из 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 — Sun, 25 Sep 2022 14:11:14 +0000

Majestio:

Цитата Qraizer @ 25.09.22, 13:05

Вот где goto во всей красе, без него даже циклы нормально написать зачастую невозможно.

По красоте. Да здравствует прекрасный оператор GOTO!!! :victory:

Сохранение и восстановление состояния обработки

Qraizer — Sun, 25 Sep 2022 13:05:12 +0000

Qraizer:

Цитата Majestio @ 25.09.22, 03:58

Кстати, стадию отрицания оператора GOTO можно быстрее и успешнее пережить - посетив всего пару курсов экстремального быдлокодинга на бейсеке

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

Добавлено 25.09.22, 13:13
Вот для примера определение номера партиции (некоторые тесты из-за размера приходилось бить на части) теста в его ID.

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

Сохранение и восстановление состояния обработки

Majestio — Sun, 25 Sep 2022 10:29:41 +0000

Majestio:

Цитата Wound @ 25.09.22, 08:54

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

Цитата Wound @ 25.09.22, 08:54

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

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

Сохранение и восстановление состояния обработки

Wound — Sun, 25 Sep 2022 08:54:38 +0000

Wound:

Цитата Majestio @ 25.09.22, 03:58

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

Цитата Majestio @ 25.09.22, 03:58

Сохранение и восстановление состояния обработки

Majestio — Sun, 25 Sep 2022 03:58:36 +0000

Majestio:

Цитата Wound @ 24.09.22, 22:33

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

Цитата Wound @ 24.09.22, 22:33

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

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

Цитата Wound @ 24.09.22, 22:33

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

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

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

Кстати, стадию отрицания оператора GOTO можно быстрее и успешнее пережить - посетив всего пару курсов экстремального быдлокодинга на бейсеке 8-)

Сохранение и восстановление состояния обработки

Wound — Sat, 24 Sep 2022 22:33:31 +0000

Wound:

Цитата Majestio @ 24.09.22, 21:57

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

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

Цитата korvin @ 24.09.22, 22:28

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

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

Добавлено 24.09.22, 23:01

Цитата Majestio @ 24.09.22, 15:43

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

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

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

Добавлено 24.09.22, 23:04

Цитата Majestio @ 24.09.22, 15:43

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

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

Добавлено 24.09.22, 23:08

Цитата Majestio @ 24.09.22, 15:43

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

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

Сохранение и восстановление состояния обработки

korvin — Sat, 24 Sep 2022 22:28:51 +0000

korvin:

Цитата Wound @ 24.09.22, 21:31

писать 100 000 строк кода в функции main - в этом ничего плохого нет.

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

Сохранение и восстановление состояния обработки

Majestio — Sat, 24 Sep 2022 21:57:06 +0000

Majestio:

Цитата Wound @ 24.09.22, 21:31

и что вообще писать 100 000 строк кода в функции main - в этом ничего плохого нет.

Сохранение и восстановление состояния обработки

Wound — Sat, 24 Sep 2022 21:31:16 +0000

Wound:

Цитата Majestio @ 24.09.22, 15:43

Вангую ... наберешься злости и давай спорить.

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

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

Добавлено 24.09.22, 21:32

Цитата Majestio @ 24.09.22, 15:43

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

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

Добавлено 24.09.22, 21:34

Цитата Majestio @ 24.09.22, 15:43

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

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

Добавлено 24.09.22, 21:42

Цитата korvin @ 24.09.22, 16:28

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

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

Цитата korvin @ 24.09.22, 16:28

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

Что то мне это напомнило... А да, ты же и задизил мое решение, которое выглядит именно так. Единственное что вместо указателя на следующую процедуру/функцию - у меня возвращается название класса.
Ну ниче, еще немного глядишь на ООП перепишешь, получится нечто похожее на то, что я предложил.

Сохранение и восстановление состояния обработки

korvin — Sat, 24 Sep 2022 16:28:46 +0000

korvin:

Цитата Majestio @ 24.09.22, 15:43

korvin предложил оптимизацию - не разделять "процессы" и "решения". И это, ящетаю, качественная модернизация подхода!

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

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

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:

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

Сохранение и восстановление состояния обработки

Majestio — Sat, 24 Sep 2022 15:43:47 +0000

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

Цитата Wound @ 20.09.22, 14:32

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

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

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

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

Скрытый текст

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

Сохранение и восстановление состояния обработки

Wound — Tue, 20 Sep 2022 14:32:32 +0000

Wound:

Цитата korvin @ 20.09.22, 11:29

Какие условия задачи? По-твоему, новый процесс куда добавляется? В вакуум? Чтобы что? Чтобы просто так висел в сторонке?

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

Цитата korvin @ 20.09.22, 11:29

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

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

Цитата korvin @ 20.09.22, 11:29

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

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

Цитата korvin @ 20.09.22, 11:29

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

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

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

Цитата korvin @ 20.09.22, 11:29

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

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

Цитата korvin @ 20.09.22, 11:29

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

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

Цитата korvin @ 20.09.22, 11:29

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

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

Цитата korvin @ 20.09.22, 11:29

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

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

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

Цитата korvin @ 20.09.22, 11:29

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

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

Сохранение и восстановление состояния обработки

korvin — Tue, 20 Sep 2022 11:29:04 +0000

korvin:

Цитата Wound @ 20.09.22, 08:57

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

Какие условия задачи? По-твоему, новый процесс куда добавляется? В вакуум? Чтобы что? Чтобы просто так висел в сторонке?

Типа такого, да?
Majestio_machine_v2_vacuum.png (, : 229)

:facepalm:

Цитата Wound @ 20.09.22, 08:57

Во первых ты там половину отсебятины добавил

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

Цитата Wound @ 20.09.22, 08:57

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

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

Цитата Wound @ 20.09.22, 08:57

Где тут нарушение S ?

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

Цитата Wound @ 20.09.22, 08:57

Я же говорю - ты из пальца высосал свои шаги

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

Цитата Wound @ 20.09.22, 08:57

не не не, ты в свой код внес ровно те же самые изменения что и в мой(ну за исключением константы).

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

Цитата Wound @ 20.09.22, 08:57

Ты добавил процесс, добавил какое то decision5 как ты там выразился,

Ага, добавил ровно то, что требовалось.

Цитата Wound @ 20.09.22, 08:57

Ты изменил вот эту соплю или что это(предполагаю это решение процесса2):

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

Цитата Wound @ 20.09.22, 08:57

Опять же изменил константу. Т.е. ты внес плюс минус те же самые изменения. в свой код.

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

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

Цитата korvin @ 20.09.22, 08:35

Таким образом, твои «независимые классы» независимы лишь иллюзорно, и твой код просто скрывает эти связи, запутывая читателя.

Как и «масштабируемость» твоя илюзорна.

Сохранение и восстановление состояния обработки

Wound — Tue, 20 Sep 2022 08:57:22 +0000

Wound:

Цитата korvin @ 20.09.22, 08:35

Вот тебе схема с новым процессом:

Ааа, то есть изначально шла речь про просто добавление нового процесса, а теперь ты решил изменить условия всей задачи и других процессов, браво! Так тогда и тебе и majestio придется менять все условия. В чем вопрос, если ты изменил условия задачи?

Цитата korvin @ 20.09.22, 08:35

Вот diff: https://quickdiff.net/?unique_id=C835D453-8...68-DBDE2D1B54C6

Что мы видим в данном изменении?

Во первых ты там половину отсебятины добавил и переписал(зачем то, во вторых ты взял первый пример, в последнем примере там и так уже 5 процессов). Единственное что придется при добавлении нового процесса менять - это константу количества процессов. Мне лень было ее выносить куда то в отдельный базовый класс. И все. В данном случае - я прекрасно понимал что придется ее менять так же, при добавлении, но лень мне уже было ее выносить куда то.

Цитата korvin @ 20.09.22, 08:35

Есть? Есть: прописали Process 5 в Process2DecisionHandler.

Цитата korvin @ 20.09.22, 08:35

Есть? Есть.

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

Цитата korvin @ 20.09.22, 08:35

Итого, в таком простом изменении 2 попадания, из которых одно (пункт 1) — прямое нарушение SOILD.

Где тут нарушение S ?

Цитата korvin @ 20.09.22, 08:35

Как бонус, ты в своей «классной ООП-архитектуре» забыл абстрагировать ячейки памяти, в результате пришлось в каждом классе процесса править константу MaxSizeValues. Ещё одно нарушение SOILD.
Кстати, почему в методе Execute размер списка проверяется, а в методе Decision — нет?

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

Цитата korvin @ 20.09.22, 08:35

Как видно, никаких изменений в реализациях process_2 и decision_2 в модуле Majestio_machine нет. Из дополнительного только 1) изменение размера памяти и 2) изменение самого автомата в соответствие с изменившимися связями на схеме.

не не не, ты в свой код внес ровно те же самые изменения что и в мой(ну за исключением константы).
Ты добавил процесс, добавил какое то decision5 как ты там выразился,
Ты изменил вот эту соплю или что это(предполагаю это решение процесса2):
| Proc_2 -> () --> M.process_2 --> M.decision_2 --> yes Proc_3 ~no:Proc_5 --> loop

Опять же изменил константу. Т.е. ты внес плюс минус те же самые изменения. в свой код.

Сохранение и восстановление состояния обработки

korvin — Tue, 20 Sep 2022 08:35:42 +0000

korvin:

Цитата Wound @ 20.09.22, 05:59

Фигню не неси, а?

:facepalm:

Вот тебе схема с новым процессом:
Majestio_machine_v2.png (, : 262)

Вот ТВОЙ код с добавлением нового процесса

using System;

using System.Collections.Generic;

using System.Linq;

using Challenge.Interfaces;

//! Interfaces

namespace Challenge.Interfaces

{

public interface IDecisionHandler

{

string HandleDecision(bool decision);

}

public interface IProcess

{

void Execute(List<int> values);

bool Decision(List<int> values);

}

namespace Challenge

{

//! DecisionhandlerContext

public class DecisionHandlerContext

{

private Dictionary<string, IDecisionHandler> _handlers;

public DecisionHandlerContext()

{

_handlers = new Dictionary<string, IDecisionHandler>();

}

public void RegisterHandler(string processName, IDecisionHandler decisionHandler)

{

if (String.IsNullOrEmpty(processName) || decisionHandler == null)

throw new Exception("Argument can't be null");

_handlers.Add(processName, decisionHandler);

}

public string HandleDecisionAndGetNextStep(string processName, bool decision)

{

if (String.IsNullOrEmpty(processName))

throw new Exception("Invalid arguments");

if(_handlers.TryGetValue(processName, out var handler))

{

return handler.HandleDecision(decision);

}

throw new Exception("Handle error");

}

public class Process1DecisionHandler : IDecisionHandler

{

public string HandleDecision(bool decision)

{

if(decision)

return Process4.ProcessName;

return Process3.ProcessName;

}

public class Process2DecisionHandler : IDecisionHandler

{

public string HandleDecision(bool decision)

{

if (decision)

return Process3.ProcessName;

return Process5.ProcessName;

}

public class Process3DecisionHandler : IDecisionHandler

{

public string HandleDecision(bool decision)

{

if (decision)

return Process2.ProcessName;

return Process1.ProcessName;

}

public class Process4DecisionHandler : IDecisionHandler

{

public string HandleDecision(bool decision)

{

if (decision)

return Process6.ProcessName;

return Process2.ProcessName;

}

public class Process5DecisionHandler : IDecisionHandler

{

public string HandleDecision(bool decision)

{

if(decision)

return Process4.ProcessName;

return Process3.ProcessName;

}

public class Process6DecisionHandler : IDecisionHandler

{

public string HandleDecision(bool decision)

{

return String.Empty;

}

//! Process1

public class Process1 : IProcess

{

private const int MaxSizeValues = 5;

public static string ProcessName => "1";

public void Execute(List<int> values)

{

if (values == null || values.Count > MaxSizeValues)

throw new InvalidOperationException("List of values is empty...");

++values[0];

}

public bool Decision(List<int> values)

{

return (values.Sum() % 2) == 0;

}

//! Process2

public class Process2 : IProcess

{

private const int MaxSizeValues = 5;

public static string ProcessName => "2";

public bool Decision(List<int> values)

{

return (values.Sum() % 7) > 0;

}

public void Execute(List<int> values)

{

if (values == null || values.Count > MaxSizeValues)

throw new InvalidOperationException("List of values is empty...");

values[1] += values[3] + 1;

}

//! Process3

public class Process3 : IProcess

{

private const int MaxSizeValues = 5;

public static string ProcessName => "3";

public bool Decision(List<int> values)

{

var existOdd = values.Any(e => e % 2 != 0);

return !existOdd;

}

public void Execute(List<int> values)

{

if (values == null || values.Count > MaxSizeValues)

throw new InvalidOperationException("List of values is empty...");

if ( (values[0] + values[1]) % 3 > 0 )

values[2] += 7;

}

//! Process4

public class Process4 : IProcess

{

private const int MaxSizeValues = 5;

public static string ProcessName => "4";

public bool Decision(List<int> values)

{

return values.Sum() > 24;

}

public void Execute(List<int> values)

{

if (values == null || values.Count > MaxSizeValues)

throw new InvalidOperationException("List of values is empty...");

if ((values[0] + values[2]) % 5 != 4)

++values[3];

}

//! Process4

public class Process5 : IProcess

{

private const int MaxSizeValues = 5;

public static string ProcessName => "5";

public bool Decision(List<int> values)

{

return values[4] > 0;

}

public void Execute(List<int> values)

{

if (values == null || values.Count > MaxSizeValues)

throw new InvalidOperationException("List of values is empty...");

++values[4];

}

//! Process6

public class Process6 : IProcess

{

public static string ProcessName => "6";

public bool Decision(List<int> values)

{

return true;

}

public void Execute(List<int> values)

{

}

//! ProcessContext

public class ProcessContext

{

private Dictionary<string, IProcess> _processes;

private DecisionHandlerContext _handlerContext;

public ProcessContext()

{

_processes = new Dictionary<string, IProcess>();

_handlerContext = new DecisionHandlerContext();

}

public ProcessContext AddProcess(string proccesName, IProcess process, IDecisionHandler handler)

{

if (String.IsNullOrEmpty(proccesName) || process == null)

throw new Exception("Argument can't be null");

_processes.Add(proccesName, process);

_handlerContext.RegisterHandler(proccesName, handler);

return this;

}

public bool RunProcessAndCheckDecision(string processName, List<int> values)

{

if(_processes.TryGetValue(processName, out var proc))

{

if (proc == null)

throw new Exception($"Process with name '{processName}' is null.");

proc.Execute(values);

return proc.Decision(values);

}

throw new Exception($"Process with name '{processName}' not found.");

}

public void RunAllProcesses(int step, string startProcessName, List<int> values)

{

string currentProcessName = startProcessName;

while (true)

{

Console.WriteLine($"Step {step}\t Proc: {currentProcessName}\t {String.Join(" ", values)}");

var result = RunProcessAndCheckDecision(currentProcessName, values);

currentProcessName = _handlerContext.HandleDecisionAndGetNextStep(currentProcessName, result);

if (String.IsNullOrEmpty(currentProcessName))

break;

++step;

}

//! Programm

public class Program

{

static void Main(string[] args)

{

try

{

List<int> values = new List<int> { 0, 0, 0, 0, 0 };

ProcessContext processContext = new ProcessContext();

processContext

.AddProcess(Process1.ProcessName, new Process1(), new Process1DecisionHandler())

.AddProcess(Process2.ProcessName, new Process2(), new Process2DecisionHandler())

.AddProcess(Process3.ProcessName, new Process3(), new Process3DecisionHandler())

.AddProcess(Process4.ProcessName, new Process4(), new Process4DecisionHandler())

.AddProcess(Process5.ProcessName, new Process5(), new Process5DecisionHandler())

.AddProcess(Process6.ProcessName, new Process6(), new Process6DecisionHandler());

processContext.RunAllProcesses(1, Process1.ProcessName, values);

Console.WriteLine("--------------------------");

List<int> savedValues = new List<int> { 3, 1, 14, 1, 0 };

processContext.RunAllProcesses(9, Process2.ProcessName, savedValues);

}

catch(Exception error)

{

Console.WriteLine(error.Message);

}

— https://rextester.com/MWCA94654

Вот diff: https://quickdiff.net/?unique_id=C835D453-8...68-DBDE2D1B54C6

Что мы видим в данном изменении?

Цитата korvin @ 18.09.22, 04:52

1) новый процесс прописать в каком-то decision'e (откуда он должен будет запускаться)

Есть? Есть: прописали Process 5 в Process2DecisionHandler.

Цитата korvin @ 18.09.22, 04:52

2) старый процесс прописать куда-то в новое место

Есть? Нет: старый процесс 4 теперь вызывается из нового процесса. Если бы старый процесс нужно было бы перепривязать в другой старый процесс, то и тут было бы «Есть».

Цитата korvin @ 18.09.22, 04:52

3) зарегистрировать новый процесс и decisionHandler в ProcessContext.

Есть? Есть.

Цитата korvin @ 18.09.22, 04:52

4) Поправить тесты изменённых decision'ов.

Есть? Условно говоря, возможно. Тестов у тебя нет, если бы были, пришлось бы править тест Process2DecisionHandler, хотя сейчас Handler'ы выглядят тривиальными, не требующими тестирования.

Итого, в таком простом изменении 2 попадания, из которых одно (пункт 1) — прямое нарушение SOILD.

Как бонус, ты в своей «классной ООП-архитектуре» забыл абстрагировать ячейки памяти, в результате пришлось в каждом классе процесса править константу MaxSizeValues. Ещё одно нарушение SOILD.
Кстати, почему в методе Execute размер списка проверяется, а в методе Decision — нет?

Вот, например, изменения в версии на Ocaml, со switch-case-loop

module type Machine =

sig

type data = int array

val init : ?data:data -> unit -> unit

val dump : unit -> data

type process = unit -> unit

val process_1 : process

val process_2 : process

val process_3 : process

val process_4 : process

val process_5 : process

type decision = unit -> bool

val decision_1 : decision

val decision_2 : decision

val decision_3 : decision

val decision_4 : decision

val decision_5 : decision

end

module Program (M : Machine) =

struct

type state =

| Proc_1

| Proc_2

| Proc_3

| Proc_4

| Proc_5

| Stop

let ( --> ) = ( |> )

let yes y ~no:n decision = if decision then y else n

let rec run count state =

log_state count state ;

let loop = run (count + 1) in

match state with

| Proc_1 -> () --> M.process_1 --> M.decision_1 --> yes Proc_4 ~no:Proc_3 --> loop

| Proc_2 -> () --> M.process_2 --> M.decision_2 --> yes Proc_3 ~no:Proc_5 --> loop

| Proc_3 -> () --> M.process_3 --> M.decision_3 --> yes Proc_2 ~no:Proc_1 --> loop

| Proc_4 -> () --> M.process_4 --> M.decision_4 --> yes Stop ~no:Proc_2 --> loop

| Proc_5 -> () --> M.process_5 --> M.decision_5 --> yes Proc_4 ~no:Proc_3 --> loop

| Stop -> ()

and log_state count state =

let data = M.dump () in

Printf.printf "Step: %2d %s %s\n" count (state_string state) (data_string data)

and state_string s =

match s with

| Proc_1 -> "Process 1"

| Proc_2 -> "Process 2"

| Proc_3 -> "Process 3"

| Proc_4 -> "Process 4"

| Proc_5 -> "Process 5"

| Stop -> "Stop "

and data_string data =

data --> Array.map (Printf.sprintf " %2d") --> Array.to_list --> String.concat " "

end

module Majestio_machine : Machine =

struct

let size = 5

let cell = Array.make size 0

type data = int array

let init ?(data=[||]) () =

let n = min size (Array.length data) in

if n = 0

then Array.fill cell 0 size 0

else Array.blit data 0 cell 0 n

let dump () = Array.copy cell

type process = unit -> unit

let process_1 () =

cell.(0) <- cell.(0) + 1

let process_2 () =

cell.(1) <- cell.(1) + cell.(3) + 1

let process_3 () =

let sum_0_1 = cell.(0) + cell.(1) in

if sum_0_1 mod 3 <> 0 then

cell.(2) <- cell.(2) + 7

let process_4 () =

let sum_0_2 = cell.(0) + cell.(2) in

if sum_0_2 mod 5 <> 4 then

cell.(3) <- cell.(3) + 1

let process_5 () =

cell.(4) <- cell.(4) + 1

type decision = unit -> bool

let sum = Array.fold_left (+) 0

let decision_1 () = sum cell mod 2 = 0

let decision_2 () = sum cell mod 7 > 0

let decision_3 () =

let is_even x = x mod 2 = 0 in

Array.for_all is_even cell

let decision_4 () = sum cell > 24

let decision_5 () = cell.(4) > 0

end

let main () =

let module Machine = Majestio_machine in

let module Program = Program (Machine) in

Machine.init () ;

Program.run 1 Program.Proc_1 ;

print_endline "----------------------------------------------------------------" ;

Machine.init ~data:[| 3; 1; 14; 1; 0 |] () ;

Program.run 9 Program.Proc_2 ;

print_endline "----------------------------------------------------------------" ;

print_endline "done"

let () = main ()

— https://rextester.com/WKONS22441

Вот diff: https://quickdiff.net/?unique_id=EDAE41DF-0...35-F78B02FB93DF

Как видно, никаких изменений в реализациях process_2 и decision_2 в модуле Majestio_machine нет. Из дополнительного только 1) изменение размера памяти и 2) изменение самого автомата в соответствие с изменившимися связями на схеме.

Таким образом, твои «независимые классы» независимы лишь иллюзорно, и твой код просто скрывает эти связи, запутывая читателя.

Сохранение и восстановление состояния обработки

Majestio — Tue, 20 Sep 2022 08:22:18 +0000

Majestio:

Цитата Wound @ 26.08.22, 20:55

Ок

Сохранение и восстановление состояния обработки

Wound — Tue, 20 Sep 2022 05:59:58 +0000

Wound:

Цитата korvin @ 18.09.22, 04:52

Не полностью: при добавлении нового процесса в твоём примере нужно будет:

Фигню не неси, а? Я щас тебе таких же шагов повысасываю из пальца. Потому что, что в моих примерах, что в его примерах - сделать нужно тоже самое.
В моем - добавляешь класс процесса, класс обработки решения, регистрируешь это в main. все. остальные детали идут из условия, у него это будет добавление лямбды во вторгой задаче, либо условия в switch.

Цитата korvin @ 18.09.22, 04:52

Итого из-за добавления одного процесса нужно править кучу классов. А как же SOLID?

Мне не нужно править кучу классов. Это ты из за того что не понимаешь что ты несешь, решил очередную чушь принести. И ничего там не нарушается.

Цитата korvin @ 18.09.22, 04:52

В наших же, с Majestio, примерах нужно править только один/два «класса» — switch-case и словарь «лямбд». И добавить тесты для новой лямбды (править тесты других decision'ов не нужно)

У него в решениях нет классов. Алё. И править ему придется ровно столько же, сколько и мне. Мде добавить 2 класса, и добавить их регистрацию, чтоб они вызвались. И ему две функции/лямбды. плюс добавить в его массив эти лямбды либо добавить case для первого пример.

Ты мне скажи - ты может быть количество строчек считаешь? Так прямо об этом и скажи тогда, а не виляй туда сюда.

Цитата korvin @ 18.09.22, 04:52

Функции (лямбды) также прекрасно тестируются по-отдельности.

Я комментирую написанный уже готовый код. Иди протестируй его лямбды, не изменяя его примера. Тут притензии не к лямбдам как таковым, а к тому как они юзаются.

Цитата korvin @ 18.09.22, 04:52

А если лямбды вынести из main в namespace challenge, будет менее херово?

То ты уже начнешь рефакторить его код, прям сходу.

Сохранение и восстановление состояния обработки

Majestio — Sun, 18 Sep 2022 10:37:59 +0000

Majestio:

Цитата korvin @ 18.09.22, 10:09

Посмотри моё решение на Хаскелле и вопрос отпадёт сам собой.

Да, объединение в одну таблицу и Process, и Decision - интересный вариант!
Тогда ветвления типа switch-case можно разложить на последовательные if-then-else вообще без накладных расходов.

Сохранение и восстановление состояния обработки

korvin — Sun, 18 Sep 2022 10:09:50 +0000

korvin:

Цитата Wound @ 16.09.22, 22:14

Ну во первых мне честно лень добавлять еще 45 процессов. Это тупая копипаста получится. Схема от этого особо не изменится

Детализируй текущую схему на более мелкие шаги, делов-то.

Majestio_machine_2_smaller.png (, : 361)

Полноразмерное изображение: https://snipboard.io/87seH3.jpg

Добавлено 18.09.22, 10:17

Цитата Majestio @ 18.09.22, 09:37

а что делать, если вдруг, по каким-то соображениям, нам нужно организовать так, чтобы очередной D-i возвращал не true/false, а к примеру 0..17?

Посмотри моё решение на Хаскелле и вопрос отпадёт сам собой.

Подсказка

Все процессы и проверки возвращают число: адрес следующего шага (state).

State	Name	Return State
0	Stop	0
1	Process 1	5
2	Process 2	6
3	Process 3	7
4	Process 4	5
5	Decision 1	4\|3
6	Decision 2	3\|4
7	Decision 3	2\|1
8	Decision 4	0\|2

Сохранение и восстановление состояния обработки

Majestio — Sun, 18 Sep 2022 09:37:43 +0000

Majestio:

Цитата D_KEY @ 18.09.22, 07:36

Кажется, у вас тут зарождается интересный спор.

Он тлеет ... и я вот думаю, подбросить дровишек или нет ... И больше думаю "да" :lol:

Смотрите какой вопрос

Приблизительно все наши решения сводились к таблице состояний и переходов вида:

State	Process	Descision	Jump Yes	Jump No
1	P-1	D-1	J-11	J-12
2	P-2	D-2	J-21	J-22
...	...	...	...	...
n	P-n	D-n	J-n1	J-n2

Вопрос: а что делать, если вдруг, по каким-то соображениям, нам нужно организовать так, чтобы очередной D-i возвращал не true/false, а к примеру 0..17? Блок-схему алгоритма пересматривать, таблицу переходов модернизировать? Или что-то еще ... Ваши соображения? :rolleyes:

Сохранение и восстановление состояния обработки

D_KEY — Sun, 18 Sep 2022 07:36:46 +0000

D_KEY: Эх. Надо будет хоть ваши варианты посмотреть как-нибудь, раз сам слился :)

Кажется, у вас тут зарождается интересный спор.

Сохранение и восстановление состояния обработки

korvin — Sun, 18 Sep 2022 04:52:20 +0000

korvin:

Цитата Qraizer @ 17.09.22, 23:31

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

Э-м… Так переходы и действия составляют 99% логики, что там в универсальной части? Цикл for?

Цитата Wound @ 17.09.22, 23:42

я не знаю - что надо взять чтоб отжирать 90% ресурсов ))

Думаю, Qraizer имел в виду, что из всех ресурсов, потребляемых программой, 90% будут составлять накладные расходы на фреймворк.

Цитата Wound @ 17.09.22, 21:55

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

Не полностью: при добавлении нового процесса в твоём примере нужно будет:

1) новый процесс прописать в каком-то decision'e (откуда он должен будет запускаться)
Типа
– был decision3Handler -> if true then Process2.Name …
– должен стать decision3Handler -> if true then Process100.Name …

2) старый процесс ( Process2.Name ) прописать куда-то в новое место
И так далее, пока цепь не замкнётся.

3) зарегистрировать новый процесс и decisionHandler в ProcessContext.

4) Поправить тесты изменённых decision'ов.

Итого из-за добавления одного процесса нужно править кучу классов. А как же SOLID?

В наших же, с Majestio, примерах нужно править только один/два «класса» — switch-case и словарь «лямбд». И добавить тесты для новой лямбды (править тесты других decision'ов не нужно)

Цитата Wound @ 17.09.22, 21:55

их можно оттестировать по отдельности например

Функции (лямбды) также прекрасно тестируются по-отдельности.

Цитата Wound @ 17.09.22, 21:55

Плюс лямбды твои, они у тебя гвоздями прибиты к переменной, объявленной в функции main -> A, а это очень херово.

А если лямбды вынести из main в namespace challenge, будет менее херово?

Сохранение и восстановление состояния обработки

Majestio — Sun, 18 Sep 2022 00:33:24 +0000

Majestio:

Цитата Wound @ 17.09.22, 21:55

представь что 100 человек написало по 1 классу

Представь что 100 человек написало по 1-й лямбде :P

Цитата Wound @ 17.09.22, 21:55

Плюс лямбды твои, они у тебя гвоздями прибиты к переменной, объявленной в функции main -> A, а это очень херово.

А в лямбду можно еще параметры передавать :P а видимость всего внешнего запретить. А можно вообще функциями оформить. Но мне однострочные лямбды кажутся красивее однострочных функций.

Сохранение и восстановление состояния обработки

Wound — Sat, 17 Sep 2022 23:42:57 +0000

Wound:

Цитата Qraizer @ 17.09.22, 23:31

Ну подумаешь, фрейморк будет отжирать 90% ресурсов.

Не будет.

Добавлено 17.09.22, 23:44
Хотя если под какие нибудь микроконтроллеры програмить, то там да - наверно надо за памятью следить. Просто с текущими тенденциями, я не знаю - что надо взять чтоб отжирать 90% ресурсов ))

Сохранение и восстановление состояния обработки

Qraizer — Sat, 17 Sep 2022 23:31:03 +0000

Qraizer:

Цитата korvin @ 17.09.22, 21:32

Цитата Qraizer @ 17.09.22, 21:28

конечный автомат

Гм, тогда к чему было:

Цитата Qraizer @ 16.09.22, 23:42

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

Я большей частью имел в виду хранение состояния через сериализацию. Как оно у кого будет реализовано, как бы без разницы. Я вот думал забабахать boost:serialisation, шоб вам тут мёдом не. :rolleyes:

Цитата korvin @ 17.09.22, 21:32

Или ты про конкретно этот паттерн?

Ну да, он самый. Но вот как раз он у вас более-менее везде в той или иной форме. Опять же, какая разница, как его реализовывать. Нравится на switch(), та на здоровье, кому-то приспичило лямбдами его зарядить и переприсваивать их mainLoop, заодно лямбдами же и предикаты переходов оформить, тазарадибога.
Я вот где-то видел универсальный автомат на шаблонах, который параметризировался переходами и действиями, реализованными функторами. Формально, весь автомат метакодируется ещё при компиляции. Думал порыскать по инету и применить у себя. То-то было бы весело сравнить с коленовелосипедными.
Как я и говорил, для серьёзных задач всё это самое то, но для простых процессов накладные не оправдают расходы. Зато без goto, да. Круто, чё. Ну подумаешь, фрейморк будет отжирать 90% ресурсов.

Сохранение и восстановление состояния обработки

Wound — Sat, 17 Sep 2022 21:55:15 +0000

Wound:

Цитата Majestio @ 17.09.22, 21:51

Не, ну можно 100 классов объявить вместо лямбд, как два пальца об асфальт ;)

Фишка в том, что даже если будут 100 классов - они будут изолированы, и представлять собой конечную сущность, их можно оттестировать по отдельности например, представь что 100 человек написало по 1 классу. А с лямбдами сложнее выходит. Плюс лямбды твои, они у тебя гвоздями прибиты к переменной, объявленной в функции main -> A, а это очень херово.

Добавлено 17.09.22, 22:05
Короче как по мне - даже первый твой вариант без GOTO, выигрывает по всем параметрам второй варинт с GOTO. И по читабельности кода, и по сопровождению. Потому что первый вариант можно и оттестировать, и расшрить без особых проблем. Второй вариант(который на лямбдах) - как по мне трешак, который придется полностью переписывать, если чуть условия усложнить.

Сохранение и восстановление состояния обработки

Majestio — Sat, 17 Sep 2022 21:51:18 +0000

Majestio:

Цитата Wound @ 17.09.22, 21:48

Именно, оно уже выглядит пугающим. Когда там будет 100 лямбд - то уже будет на что посмотреть.

Не, ну можно 100 классов объявить вместо лямбд, как два пальца об асфальт ;)

Сохранение и восстановление состояния обработки

Wound — Sat, 17 Sep 2022 21:48:54 +0000

Wound:

Цитата Majestio @ 17.09.22, 21:43

На одно распухание: 2 лямбды + 1 пара значений в таблицу переходов :rolleyes:

Именно, оно уже выглядит пугающим. Когда там будет 100 лямбд - то уже будет на что посмотреть.

Сохранение и восстановление состояния обработки

Majestio — Sat, 17 Sep 2022 21:43:46 +0000

Majestio:

Цитата Wound @ 17.09.22, 21:36

Я хочу посмотреть как распухнут твои исходники на плюсах.

На одно распухание: 2 лямбды + 1 пара значений в таблицу переходов :rolleyes:

Добавлено 17.09.22, 21:44

Цитата Wound @ 17.09.22, 21:36

Я почти неделю ждал решения на goto, чтоб его обосрать и где оно?

Прости!!! :lool:

Сохранение и восстановление состояния обработки

Wound — Sat, 17 Sep 2022 21:36:55 +0000

Wound:

Цитата Majestio @ 17.09.22, 21:34

А вот при постановке задачи "пересчеты-с-сохранением" - многовложенные циклы в 17 раз хуже использования прекрасного оператора GOTO :rolleyes:

Ты нигде его не использовал свой goto. Твой ивент - профанация. Я почти неделю ждал решения на goto, чтоб его обосрать и где оно? Только korvin, то что у тебя на языке было, написал сегодня или вчера кодом. И все.
Короче blah-blah-blah... goto, goto, и где он этот goto в твоих исходниках? Я не вижу его. <_<

Добавлено 17.09.22, 21:39
Я тебе больше скажу - давай расширим ивент до 50 процессов. Только мне лень придумывать им решения. Я хочу посмотреть как распухнут твои исходники на плюсах.

Сохранение и восстановление состояния обработки

Majestio — Sat, 17 Sep 2022 21:34:42 +0000

Majestio:

Цитата Qraizer @ 17.09.22, 21:28

Ну тогда и я вскроюсь. В главном цикле приложения: конечный автомат для решений и переходов + сериализация для хранения состояний. Сохранение/восстановление тоже состояния автомата. Всё.

Да, у всех один и тот же подход. А вот при постановке задачи "пересчеты-с-сохранением" - многовложенные циклы в 17 раз хуже использования прекрасного оператора GOTO :rolleyes:

Сохранение и восстановление состояния обработки

Wound — Sat, 17 Sep 2022 21:33:30 +0000

Wound:

Цитата korvin @ 17.09.22, 21:32

Или ты про конкретно этот паттерн?

Скорее он про switch в цикле, ИМХО.

Добавлено 17.09.22, 21:34
Я так предполагаю что то типа этого: http://www.devexp.ru/2011/02/konechnye-avtomaty-v-c/
Хотя могу ошибаться. В плюсах я только про такие автоматы слышал.

Сохранение и восстановление состояния обработки

korvin — Sat, 17 Sep 2022 21:32:21 +0000

korvin:

Цитата Qraizer @ 17.09.22, 21:28

конечный автомат

Гм, тогда к чему было:

Цитата Qraizer @ 16.09.22, 23:42

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

?

Или ты про конкретно этот паттерн?

Сохранение и восстановление состояния обработки

Majestio — Sat, 17 Sep 2022 21:32:12 +0000

Majestio:

Цитата Wound @ 17.09.22, 21:17

Видишь, ты даже в синтетической задаче не нашел применение этому оператору.

Ну в моем первом варианте - использование switch-case только это маскирует формально, а по сути - тот же if-goto, только вид сбоку :rolleyes:

Сохранение и восстановление состояния обработки

Qraizer — Sat, 17 Sep 2022 21:28:26 +0000

Qraizer: Ну тогда и я вскроюсь. В главном цикле приложения: конечный автомат для решений и переходов + сериализация для хранения состояний. Сохранение/восстановление тоже состояния автомата. Всё.

Сохранение и восстановление состояния обработки

Wound — Sat, 17 Sep 2022 21:17:13 +0000

Wound:

Цитата Majestio @ 17.09.22, 21:01

label: if (true == false) goto label;

:bad:

Добавлено 17.09.22, 21:20

Цитата Majestio @ 17.09.22, 21:01

Вариант 1 (С++, без GOTO)

Видишь, ты даже в синтетической задаче не нашел применение этому оператору.

Сохранение и восстановление состояния обработки

korvin — Sat, 17 Sep 2022 21:15:28 +0000

korvin:

Ocaml #1

module Memory =

struct

type cells = int array

let size = 4

let alloc () = Array.make size 0

end

module type CPU =

sig

type process = Memory.cells -> unit

val process_1 : process

val process_2 : process

val process_3 : process

val process_4 : process

type decision = Memory.cells -> bool

val decision_1 : decision

val decision_2 : decision

val decision_3 : decision

val decision_4 : decision

end

module Machine (CPU : CPU) =

struct

open CPU

type cpu_state =

| Process_1

| Process_2

| Process_3

| Process_4

| Stop

type machine =

{ mutable cpu_state : cpu_state

; mutable cpu_counter : int

; memory : Memory.cells }

let new_machine ?(cpu_state=Process_1) ?(cpu_counter=0) ?(memory_init=[||]) () =

let memory = Memory.alloc () in

for i = 0 to min (Memory.size - 1) (Array.length memory_init - 1) do

memory.(i) <- memory_init.(i)

done ;

{ cpu_state = cpu_state

; cpu_counter = cpu_counter

; memory = memory }

let cpu process machine =

process machine.memory ;

{ machine with cpu_counter = machine.cpu_counter + 1 }

let branch decision machine =

(machine, decision machine.memory)

let yes y ~no (machine, flag) =

{ machine with cpu_state = if flag then y else no }

let ( ==> ) = ( |> )

let rec run machine =

describe machine ;

match machine.cpu_state with

| Process_1 -> machine ==> cpu process_1 ==> branch decision_1 ==> yes Process_4 ~no: Process_3 ==> run

| Process_2 -> machine ==> cpu process_2 ==> branch decision_2 ==> yes Process_3 ~no: Process_4 ==> run

| Process_3 -> machine ==> cpu process_3 ==> branch decision_3 ==> yes Process_2 ~no: Process_1 ==> run

| Process_4 -> machine ==> cpu process_4 ==> branch decision_4 ==> yes Stop ~no: Process_2 ==> run

| Stop -> ()

and describe { cpu_state ; cpu_counter ; memory } =

Printf.printf "Step: %2d %-8s %s\n" cpu_counter (state_string cpu_state) (mem_string memory)

and state_string state =

match state with

| Process_1 -> "Proc: 1"

| Process_2 -> "Proc: 2"

| Process_3 -> "Proc: 3"

| Process_4 -> "Proc: 4"

| Stop -> "Stop "

and mem_string mem =

let str = ref "" in

for i = 0 to Memory.size - 1 do

str := !str ^ Printf.sprintf " %3d" mem.(i)

done ;

!str

end

module Majestio_CPU : CPU =

struct

type process = Memory.cells -> unit

let process_1 mem =

mem.(0) <- mem.(0) + 1

let process_2 mem =

mem.(1) <- mem.(1) + mem.(3) + 1

let process_3 mem =

let sum_0_1 = mem.(0) + mem.(1) in

if sum_0_1 mod 3 <> 0 then

mem.(2) <- mem.(2) + 7

let process_4 mem =

let sum_0_2 = mem.(0) + mem.(2) in

if sum_0_2 mod 5 <> 4 then

mem.(3) <- mem.(3) + 1

type decision = Memory.cells -> bool

let sum = Array.fold_left (+) 0

let decision_1 mem =

sum mem mod 2 = 0

let decision_2 mem =

sum mem mod 7 > 0

let decision_3 mem =

let is_even x = x mod 2 = 0 in

Array.for_all is_even mem

let decision_4 mem =

sum mem > 24

end

let main () =

let module M = Machine (Majestio_CPU) in

M.new_machine () |> M.run ;

print_endline "----------------------------------------------------------------" ;

M.new_machine

~cpu_state: M.Process_4

~cpu_counter: 9

~memory_init: [| 3; 3; 14; 1 |]

() |> M.run ;

print_endline "----------------------------------------------------------------"

let () = main ()

— https://rextester.com/YFHF41308

Ocaml #2

module type Machine =

sig

type data = int array

val init : ?data:data -> unit -> unit

val dump : unit -> data

type process = unit -> unit

val process_1 : process

val process_2 : process

val process_3 : process

val process_4 : process

type decision = unit -> bool

val decision_1 : decision

val decision_2 : decision

val decision_3 : decision

val decision_4 : decision

end

module Program (M : Machine) =

struct

type state =

| Proc_1

| Proc_2

| Proc_3

| Proc_4

| Stop

let ( --> ) = ( |> )

let yes y ~no:n decision = if decision then y else n

let rec run count state =

log_state count state ;

let loop = run (count + 1) in

match state with

| Proc_1 -> () --> M.process_1 --> M.decision_1 --> yes Proc_4 ~no:Proc_3 --> loop

| Proc_2 -> () --> M.process_2 --> M.decision_2 --> yes Proc_3 ~no:Proc_4 --> loop

| Proc_3 -> () --> M.process_3 --> M.decision_3 --> yes Proc_2 ~no:Proc_1 --> loop

| Proc_4 -> () --> M.process_4 --> M.decision_4 --> yes Stop ~no:Proc_2 --> loop

| Stop -> ()

and log_state count state =

let data = M.dump () in

Printf.printf "Step: %2d %s %s\n" count (state_string state) (data_string data)

and state_string s =

match s with

| Proc_1 -> "Process 1"

| Proc_2 -> "Process 2"

| Proc_3 -> "Process 3"

| Proc_4 -> "Process 4"

| Stop -> "Stop "

and data_string data =

data --> Array.map (Printf.sprintf " %2d") --> Array.to_list --> String.concat " "

end

module Majestio_machine : Machine =

struct

let size = 4

let cell = Array.make size 0

type data = int array

let init ?(data=[||]) () =

let n = min size (Array.length data) in

if n = 0

then Array.fill cell 0 size 0

else Array.blit data 0 cell 0 n

let dump () = Array.copy cell

type process = unit -> unit

let process_1 () =

cell.(0) <- cell.(0) + 1

let process_2 () =

cell.(1) <- cell.(1) + cell.(3) + 1

let process_3 () =

let sum_0_1 = cell.(0) + cell.(1) in

if sum_0_1 mod 3 <> 0 then

cell.(2) <- cell.(2) + 7

let process_4 () =

let sum_0_2 = cell.(0) + cell.(2) in

if sum_0_2 mod 5 <> 4 then

cell.(3) <- cell.(3) + 1

type decision = unit -> bool

let sum = Array.fold_left (+) 0

let decision_1 () = sum cell mod 2 = 0

let decision_2 () = sum cell mod 7 > 0

let decision_3 () =

let is_even x = x mod 2 = 0 in

Array.for_all is_even cell

let decision_4 () = sum cell > 24

end

let main () =

let module Machine = Majestio_machine in

let module Program = Program (Machine) in

Machine.init () ;

Program.run 1 Program.Proc_1 ;

print_endline "----------------------------------------------------------------" ;

Machine.init ~data:[| 3; 3; 14; 1 |] () ;

Program.run 9 Program.Proc_4 ;

print_endline "----------------------------------------------------------------" ;

print_endline "done"

let () = main ()

— https://rextester.com/WPDD51431

Ocaml #3

module Machine =

struct

type memory = int array

type process = memory -> unit

type decision = memory -> bool

type cpu =

{ processes : process array

; decisions : decision array }

type program = (int * int * int) array

let majestio : program = [|

1, 4, 3;

2, 3, 4;

3, 2, 1;

4, 5, 2

let rec run ?(count = 0) ?(proc = 1) cpu mem program =

log_state count proc mem ;

let proc = proc - 1 in

if 0 <= proc && proc < Array.length program then begin

let dec, yes, no = program .(proc) in

let process = cpu.processes.(proc) in

let decision = cpu.decisions.(dec-1) in

process mem ;

let next = if decision mem then yes else no in

run ~count:(count+1) ~proc:next cpu mem program

end

and log_state count process mem =

let mem = mem |> Array.map (Printf.sprintf "%2d") |> Array.to_list |> String.concat " "

in Printf.printf "Step: %2d Proc: %d %s\n" count process mem

end

module Majestio =

struct

let process_1 cell =

cell.(0) <- cell.(0) + 1

let process_2 cell =

cell.(1) <- cell.(1) + cell.(3) + 1

let process_3 cell =

let sum_0_1 = cell.(0) + cell.(1) in

if sum_0_1 mod 3 <> 0 then

cell.(2) <- cell.(2) + 7

let process_4 cell =

let sum_0_2 = cell.(0) + cell.(2) in

if sum_0_2 mod 5 <> 4 then

cell.(3) <- cell.(3) + 1

let sum = Array.fold_left (+) 0

let decision_1 cell = sum cell mod 2 = 0

let decision_2 cell = sum cell mod 7 > 0

let decision_3 cell =

let is_even x = x mod 2 = 0 in

Array.for_all is_even cell

let decision_4 cell = sum cell > 24

let cpu =

{ Machine.

processes =

process_1;

process_2;

process_3;

process_4

; decisions =

decision_1;

decision_2;

decision_3;

decision_4

}

let program =

1, 4, 3;

2, 3, 4;

3, 2, 1;

4, 5, 2

end

let main () =

Machine.run Majestio.cpu [| 0; 0; 0; 0 |] Majestio.program ;

print_endline "----------------------------------------------------------------" ;

Machine.run ~count:9 ~proc:4 Majestio.cpu [| 3; 3; 14; 1 |] Majestio.program ;

print_endline "----------------------------------------------------------------"

let () = main ()

— https://rextester.com/ARZ32340

Racket

#lang racket

(define (sum v)

(for/sum ((x (in-vector v))) x))

(define (cell c1 c2 c3 c4)

(vector c1 c2 c3 c4))

(define (mod x y)

(remainder x y))

(define (div-by? n v)

(zero? (mod v n)))

(define (all v predicate?)

(for/and ((x (in-vector v)))

(predicate? x)))

(define (are-even? x)

(zero? (mod x 2)))

(define (f l n #:left? (left? #f))

(let* ((s (format "~a" n))

(m (string-length s)))

(cond ((>= m l)

(left?

(string-append s (make-string (- l m) #\Space)))

(else

(string-append (make-string (- l m) #\Space) s)))))

(define-syntax-rule (state st) 'st)

(define (counter c) c)

(define-syntax define-machine

(syntax-rules (state -> -- < > yes no)

((_ (name (counter counter-init) (state state-init) (cell c1 c2 c3 c4))

{ -> [ proc-in

action ]

post-cond

-- yes -> yes-proc-out

-- no -> no-proc-out }

...

)

(define (name (counter counter-init) (state 'state-init) (cells #(c1 c2 c3 c4)))

(define cs (vector-copy cells))

(define-syntax cell

(syntax-rules (<- ->)

((_) cs)

((_ i) (vector-ref cs i))

((_ i <- op . vs)

(vector-set! cs i (op (cell i) . vs)))

((_ op -> predicate?)

(let ((op (op cs)))

predicate?))))

(define (proc-in)

action

(if post-cond

'yes-proc-out

'no-proc-out))

...

(let loop ((state state) (counter counter))

(printf "Step: ~a ~a ~a ~a ~a ~a~n"

(f 2 counter)

(f 10 state #:left? #t)

(f 2 (cell 0))

(f 2 (cell 1))

(f 2 (cell 2))

(f 2 (cell 3)))

(case state

((proc-in) (loop (proc-in) (+ counter 1)))

...

(else 'done)))))))

(define-machine (majestio-machine (counter 0) (state process-1) (cell 0 0 0 0))

{ -> [ process-1

(cell 0 <- + 1) ]

< (cell sum -> (div-by? 2 sum)) >

-- yes -> process-4

-- no -> process-3 }

{ -> [ process-2

(cell 1 <- + (cell 3) 1) ]

< (cell sum -> (positive? (mod sum 7))) >

-- yes -> process-3

-- no -> process-4 }

{ -> [ process-3

(unless (div-by? 3 (+ (cell 0) (cell 1)))

(cell 2 <- + 7)) ]

< (all (cell) are-even?) >

-- yes -> process-2

-- no -> process-1 }

{ -> [ process-4

(let ((c0+c2 (+ (cell 0) (cell 2))))

(unless (= (mod c0+c2 5) 4)

(cell 3 <- + 1))) ]

< (cell sum -> (> sum 24)) >

-- yes -> stop

-- no -> process-2 } )

(define (main)

(majestio-machine)

(displayln "----------------------------------------------------------------")

(majestio-machine (counter 9) (state process-4) (cell 3 3 14 1))

(displayln "----------------------------------------------------------------"))

(main)

— https://onecompiler.com/racket/3ygbcbxe2

Haskell

module Main (main) where

main :: IO ()

main = do

machine (Run 0 Process 1 [0, 0, 0, 0])

putStrLn "----------------------------------------------------------------"

machine (Run 9 Process 4 [3, 3, 14, 1])

putStrLn "----------------------------------------------------------------"

----------------------------------------------------------------

data CmdType = Process | Decision deriving (Show)

type CmdAddr = Int

type Counter = Int

type Memory = [Int]

data State

= Run Counter CmdType CmdAddr Memory

| Stop

| Fail String

instance Show State where

show Stop = "stop"

show (Fail err) = "failure: " ++ err

show (Run c Process i cells) =

"Step: " ++ align2 c ++ " Proc: " ++ show i ++ " " ++ showCells cells

where

showCells [] = ""

showCells (cell:rest) = " " ++ align2 cell ++ showCells rest

align2 n

| n < 10 = " " ++ show n

| otherwise = show n

show (Run c t i cells) = "Step " ++ show c ++ " " ++ show t ++ " " ++ show i ++ " " ++ show cells

----------------------------------------------------------------

cpu :: State -> State

cpu (Run c Process 1 [c0, c1, c2, c3]) = Run (c+1) Decision 1 [c0+1, c1, c2, c3]

cpu (Run c Decision 1 cells)

| even (sum cells) = Run c Process 4 cells

| otherwise = Run c Process 3 cells

cpu (Run c Process 2 [c0, c1, c2, c3]) = Run (c+1) Decision 2 [c0, c1+c3+1, c2, c3]

cpu (Run c Decision 2 cells)

| sum cells `mod` 7 > 0 = Run c Process 3 cells

| otherwise = Run c Process 4 cells

cpu (Run c Process 3 [c0, c1, c2, c3])

| (c0+c1) `mod` 3 /= 0 = Run (c+1) Decision 3 [c0, c1, c2+7, c3]

| otherwise = Run (c+1) Decision 3 [c0, c1, c2, c3]

cpu (Run c Decision 3 cells)

| all even cells = Run c Process 2 cells

| otherwise = Run c Process 1 cells

cpu (Run c Process 4 [c0, c1, c2, c3])

| (c0+c2) `mod` 5 /= 4 = Run (c+1) Decision 4 [c0, c1, c2, c3+1]

| otherwise = Run (c+1) Decision 4 [c0, c1, c2, c3]

cpu (Run c Decision 4 cells)

| sum cells > 24 = Run c Process 5 cells

| otherwise = Run c Process 2 cells

cpu (Run _ Process 5 _) = Stop

cpu Stop = Stop

cpu (Fail err) = Fail err

cpu state = Fail (show state)

----------------------------------------------------------------

machine :: State -> IO ()

machine Stop = return ()

machine s@(Fail _) = print s

machine s@(Run _ Process _ _) = print s >> machine (cpu s)

machine s = machine (cpu s)

— https://rextester.com/EQGX38142

package main

import (

"context"

"fmt"

)

var (

process1 = make(chan int)

process2 = make(chan int)

process3 = make(chan int)

process4 = make(chan int)

stop = make(chan int)

cell = make(Cells, 4)

)

func main() {

var ctx = context.Background()

robot(ctx)

start(0, process1, 0, 0, 0, 0)

start(9, process4, 3, 3, 14, 1)

}

func robot(ctx context.Context) {

go Block{

Name: "Proc: 1",

Receive: process1,

Process: Process1,

Decision: Decision1,

IfYes: process4,

IfNo: process3,

}.Connect(ctx)

go Block{

Name: "Proc: 2",

Receive: process2,

Process: Process2,

Decision: Decision2,

IfYes: process3,

IfNo: process4,

}.Connect(ctx)

go Block{

Name: "Proc: 3",

Receive: process3,

Process: Process3,

Decision: Decision3,

IfYes: process2,

IfNo: process1,

}.Connect(ctx)

go Block{

Name: "Proc: 4",

Receive: process4,

Process: Process4,

Decision: Decision4,

IfYes: stop,

IfNo: process2,

}.Connect(ctx)

}

func start(counter int, process chan<- int, c1, c2, c3, c4 int) {

cell[0], cell[1], cell[2], cell[3] = c1, c2, c3, c4

process <- counter

counter = <-stop

dump(counter, "Stop")

fmt.Println("----------------------------------------------------------------")

}

type (

Cells []int

Block struct {

Name string

Receive <-chan int

Process Process

Decision Decision

IfYes chan<- int

IfNo chan<- int

}

Process func()

Decision func() bool

)

func (b Block) Connect(ctx context.Context) {

for {

select {

case <-ctx.Done():

// may save here

case counter := <-b.Receive:

dump(counter, b.Name)

counter++

b.Process()

if b.Decision() {

b.yes(ctx, counter)

} else {

b.no(ctx, counter)

}

func (b Block) yes(ctx context.Context, value int) {

send(ctx, b.IfYes, value)

}

func (b Block) no(ctx context.Context, value int) {

send(ctx, b.IfNo, value)

}

/* ---------------------------------------------------------------- */

func Process1() {

cell[0]++

}

func Process2() {

cell[1] += cell[3] + 1

}

func Process3() {

if (cell[0] + cell[1])%3 != 0 {

cell[2] += 7

}

func Process4() {

if (cell[0] + cell[2])%5 != 4 {

cell[3] += 1

}

/* ---------------------------------------------------------------- */

func Decision1() bool {

return cell.sum()%2 == 0

}

func Decision2() bool {

return cell.sum()%7 > 0

}

func Decision3() bool {

return cell.areAllEven()

}

func Decision4() bool {

return cell.sum() > 24

}

/* ---------------------------------------------------------------- */

func (xs Cells) sum() (s int) {

for _, x := range xs {

s += x

}

return s

}

func (xs Cells) areAllEven() bool {

for _, x := range xs {

if x%2 != 0 {

return false

}

return true

}

func send(ctx context.Context, ch chan<- int, v int) {

select {

case ch <- v:

case <-ctx.Done():

}

func dump(c int, p string) {

fmt.Printf("Step: %2d %-10s %2d %2d %2d %2d\n",

c, p, cell[0], cell[1], cell[2], cell[3])

}

— https://go.dev/play/p/2AZ1MAlUaOp

Common Lisp

(defparameter *data* (vector 0 0 0 0))

(defun run-machine (&key (state 1) (count 0))

(labels ((dump (state)

(format t "Step: ~2d Proc: ~2d ~{ ~2d~}~%" count state (coerce *data* 'list))

(incf count)))

(tagbody

(case state

(1 (go :proc-1))

(2 (go :proc-2))

(3 (go :proc-3))

(4 (go :proc-4))

(t (go :stop)))

:proc-1

(dump 1)

(process-1)

(if (decision-1) (go :proc-4) (go :proc-3))

:proc-2

(dump 2)

(process-2)

(if (decision-2) (go :proc-3) (go :proc-4))

:proc-3

(dump 3)

(process-3)

(if (decision-3) (go :proc-2) (go :proc-1))

:proc-4

(dump 4)

(process-4)

(if (decision-4) (go :stop) (go :proc-2))

:stop

(dump 5))))

(defun process-1 ()

(incf (cell 0)))

(defun process-2 ()

(incf (cell 1) (+ (cell 3) 1)))

(defun process-3 ()

(unless (divisible (sum-cells 0 1) :by 3)

(incf (cell 2) 7)))

(defun process-4 ()

(unless (= 4 (rem (sum-cells 0 2) 5))

(incf (cell 3))))

(defun decision-1 ()

(divisible (cells-sum) :by 2))

(defun decision-2 ()

(plusp (rem (cells-sum) 7)))

(defun decision-3 ()

(all-cells #'evenp))

(defun decision-4 ()

(> (cells-sum) 24))

;------------------------------------------------

(defun cell (i)

(aref *data* i))

(defun (setf cell) (v i)

(setf (aref *data* i) v))

(defun divisible (v &key by)

(zerop (rem v by)))

(defun sum-cells (&rest indexes)

(loop for i in indexes summing (cell i)))

(defun cells-sum ()

(loop for x across *data* summing x))

(defun all-cells (predicate)

(loop for x across *data*

unless (funcall predicate x)

do (return-from all-cells nil))

;------------------------------------------------

(defun main ()

(run-machine)

(format t "----------------------------------------------------------------~%")

(let ((*data* (vector 3 3 14 1)))

(run-machine :count 9 :state 4))

(format t "----------------------------------------------------------------~%"))

(main)

— https://rextester.com/RRI70257

Сохранение и восстановление состояния обработки

Wound — Sat, 17 Sep 2022 21:12:47 +0000

Wound:

Цитата Majestio @ 17.09.22, 20:46

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

Онлайн -> https://rextester.com/PKDT40835

Код

using System;

using System.Collections.Generic;

using System.Linq;

using Challenge.Interfaces;

//! Interfaces

namespace Challenge.Interfaces

{

public interface IDecisionHandler

{

string HandleDecision(bool decision);

}

public interface IProcess

{

void Execute(List<int> values);

bool Decision(List<int> values);

}

namespace Challenge

{

//! DecisionhandlerContext

public class DecisionHandlerContext

{

private Dictionary<string, IDecisionHandler> _handlers;

public DecisionHandlerContext()

{

_handlers = new Dictionary<string, IDecisionHandler>();

}

public void RegisterHandler(string processName, IDecisionHandler decisionHandler)

{

if (String.IsNullOrEmpty(processName) || decisionHandler == null)

throw new Exception("Argument can't be null");

_handlers.Add(processName, decisionHandler);

}

public string HandleDecisionAndGetNextStep(string processName, bool decision)

{

if (String.IsNullOrEmpty(processName))

throw new Exception("Invalid arguments");

if(_handlers.TryGetValue(processName, out var handler))

{

return handler.HandleDecision(decision);

}

throw new Exception("Handle error");

}

public class Process1DecisionHandler : IDecisionHandler

{

public string HandleDecision(bool decision)

{

if(decision)

return Process4.ProcessName;

return Process3.ProcessName;

}

public class Process2DecisionHandler : IDecisionHandler

{

public string HandleDecision(bool decision)

{

if (decision)

return Process3.ProcessName;

return Process4.ProcessName;

}

public class Process3DecisionHandler : IDecisionHandler

{

public string HandleDecision(bool decision)

{

if (decision)

return Process2.ProcessName;

return Process1.ProcessName;

}

public class Process4DecisionHandler : IDecisionHandler

{

public string HandleDecision(bool decision)

{

if (decision)

return Process5.ProcessName;

return Process2.ProcessName;

}

public class Process5DecisionHandler : IDecisionHandler

{

public string HandleDecision(bool decision)

{

return String.Empty;

}

//! Process1

public class Process1 : IProcess

{

private const int MaxSizeValues = 4;

public static string ProcessName => "1";

public void Execute(List<int> values)

{

if (values == null || values.Count > MaxSizeValues)

throw new InvalidOperationException("List of values is empty...");

++values[0];

}

public bool Decision(List<int> values)

{

return (values.Sum() % 2) == 0;

}

//! Process2

public class Process2 : IProcess

{

private const int MaxSizeValues = 4;

public static string ProcessName => "2";

public bool Decision(List<int> values)

{

return (values.Sum() % 7) > 0;

}

public void Execute(List<int> values)

{

if (values == null || values.Count > MaxSizeValues)

throw new InvalidOperationException("List of values is empty...");

values[1] += values[3] + 1;

}

//! Process3

public class Process3 : IProcess

{

private const int MaxSizeValues = 4;

public static string ProcessName => "3";

public bool Decision(List<int> values)

{

var existOdd = values.Any(e => e % 2 != 0);

return !existOdd;

}

public void Execute(List<int> values)

{

if (values == null || values.Count > MaxSizeValues)

throw new InvalidOperationException("List of values is empty...");

if ( (values[0] + values[1]) % 3 > 0 )

values[2] += 7;

}

//! Process4

public class Process4 : IProcess

{

private const int MaxSizeValues = 4;

public static string ProcessName => "4";

public bool Decision(List<int> values)

{

return values.Sum() > 24;

}

public void Execute(List<int> values)

{

if (values == null || values.Count > MaxSizeValues)

throw new InvalidOperationException("List of values is empty...");

if ((values[0] + values[2]) % 5 != 4)

++values[3];

}

//! Process5

public class Process5 : IProcess

{

public static string ProcessName => "5";

public bool Decision(List<int> values)

{

return true;

}

public void Execute(List<int> values)

{

}

//! ProcessContext

public class ProcessContext

{

private Dictionary<string, IProcess> _processes;

private DecisionHandlerContext _handlerContext;

public ProcessContext()

{

_processes = new Dictionary<string, IProcess>();

_handlerContext = new DecisionHandlerContext();

}

public ProcessContext AddProcess(string proccesName, IProcess process, IDecisionHandler handler)

{

if (String.IsNullOrEmpty(proccesName) || process == null)

throw new Exception("Argument can't be null");

_processes.Add(proccesName, process);

_handlerContext.RegisterHandler(proccesName, handler);

return this;

}

public bool RunProcessAndCheckDecision(string processName, List<int> values)

{

if(_processes.TryGetValue(processName, out var proc))

{

if (proc == null)

throw new Exception($"Process with name '{processName}' is null.");

proc.Execute(values);

return proc.Decision(values);

}

throw new Exception($"Process with name '{processName}' not found.");

}

public void RunAllProcesses(string startProcessName, List<int> values)

{

string currentProcessName = startProcessName;

int step = 0;

while (true)

{

Console.WriteLine($"Step {step}\t Proc: {currentProcessName}\t {String.Join(" ", values)}");

var result = RunProcessAndCheckDecision(currentProcessName, values);

currentProcessName = _handlerContext.HandleDecisionAndGetNextStep(currentProcessName, result);

if (String.IsNullOrEmpty(currentProcessName))

break;

++step;

}

//! Programm

public class Program

{

static void Main(string[] args)

{

try

{

List<int> values = new List<int> { 0, 0, 0, 0 };

ProcessContext processContext = new ProcessContext();

processContext

.AddProcess(Process1.ProcessName, new Process1(), new Process1DecisionHandler())

.AddProcess(Process2.ProcessName, new Process2(), new Process2DecisionHandler())

.AddProcess(Process3.ProcessName, new Process3(), new Process3DecisionHandler())

.AddProcess(Process4.ProcessName, new Process4(), new Process4DecisionHandler())

.AddProcess(Process5.ProcessName, new Process5(), new Process5DecisionHandler());

processContext.RunAllProcesses(Process1.ProcessName, values);

Console.WriteLine("--------------------------");

List<int> savedValues = new List<int> { 3, 3, 14, 1 };

processContext.RunAllProcesses(Process4.ProcessName, savedValues);

}

catch(Exception error)

{

Console.WriteLine(error.Message);

}

Сохранение и восстановление состояния обработки

Majestio — Sat, 17 Sep 2022 21:01:17 +0000

Majestio: Вариант 1 (С++, без GOTO) Ссылка на онлайн-исполнение

Скрытый текст

#include <iostream>

#include <vector>

#include <algorithm>

using namespace std;

std::vector<int> Arr {0,0,0,0};

std::size_t Step = 0;

std::size_t State = 0;

void prn();

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

bool process1() {

Step++;

Arr[0]++;

int Summ = 0;

std::for_each(Arr.begin(), Arr.end(), [&](int &n){Summ += n;});

return Summ % 2 == 0;

}

bool process2() {

Step++;

Arr[1] += Arr[3] + 1;

int Summ = 0;

std::for_each(Arr.begin(), Arr.end(), [&](int &n){Summ += n;});

return Summ % 7 > 0;

}

bool process3() {

Step++;

Arr[2] += ((Arr[0]+Arr[1]) % 3 == 0) ? 0 : 7;

bool Flag = true;

std::for_each(Arr.begin(), Arr.end(), [&](int &n){if (n % 2 >0) Flag = false;});

return Flag;

}

bool process4() {

Step++;

Arr[3] += ((Arr[0]+Arr[2]) % 5 == 4) ? 0 : 1;

int Summ = 0;

std::for_each(Arr.begin(), Arr.end(), [&](int &n){Summ += n;});

return Summ > 24;

}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

void load(int pass) {

if (pass == 1) {

State = 1;

prn();

} else {

State = 4;

Arr = {3,3,14,1};

Step = 9;

prn();

}

return;

}

void prn() {

std::cout << "Step: " << Step << "\t" << "Proc: " << State << "\t"

<< Arr[0] << "\t" << Arr[1] << "\t"

<< Arr[2] << "\t" << Arr[3] << "\n";

}

// - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -

int main()

{

for (int i=1; i<3; i++) {

load(i);

bool cycle = true;

while (cycle) {

switch (State) {

case 1:

State = (process1()) ? 4:3; prn(); break;

case 2:

State = (process2()) ? 3:4; prn(); break;

case 3:

State = (process3()) ? 2:1; prn(); break;

case 4:

State = (process4()) ? 5:2; prn(); break;

default:

cycle = false; break;

}

std::cout << "----------------------------------------------------------------\n";

}

return 0;

}

Вариант 2 (С++, с прекрасным оператором GOTO) Ссылка на онлайн-исполнение

Скрытый текст

#include <functional>

#include <algorithm>

#include <iterator>

#include <iostream>

#include <numeric>

#include <vector>

int main() {

int Idx = 0;

int Step = 0;

bool Continue = true;

std::vector<int>A = {0, 0, 0, 0};

std::vector<std::vector<int>> Matrix = {{3,2},{2,3},{1,0},{4,1},{4,4}};

auto P1 = [&]() -> void { A[0]++; };

auto P2 = [&]() -> void { A[1] += A[3] + 1; };

auto P3 = [&]() -> void { A[2] += ((A[0] + A[1]) % 3 == 0) ? 0 : 7; };

auto P4 = [&]() -> void { A[3] += ((A[0] + A[2]) % 5 == 4) ? 0 : 1; };

auto Fp = [&]() -> void { };

auto D1 = [&]() -> bool { return std::accumulate(A.begin(), A.end(), 0) % 2 == 0; };

auto D2 = [&]() -> bool { return std::accumulate(A.begin(), A.end(), 0) % 7 > 0; };

auto D3 = [&]() -> bool { return std::find_if(A.begin(), A.end(), [](int i){ return i % 2 > 0; }) == A.end(); };

auto D4 = [&]() -> bool { return std::accumulate(A.begin(), A.end(), 0) > 24; };

auto Fd = [&]() -> bool { Continue = false; return false; };

auto Print = [&]() -> void {

std::cout << "Step: " << Step << "\tProc: " << (Idx+1) << "\t";

std::copy(A.begin(), A.end(), std::ostream_iterator<int>(std::cout, "\t"));

std::cout << std::endl;

};

using Process = std::function<void()>;

using Decision = std::function<bool()>;

std::vector<Process> P = {P1, P2, P3, P4, Fp};

std::vector<Decision> D = {D1, D2, D3, D4, Fd};

// Проход с начала и до конца

while(Continue) {

Print();

P[Idx]();

Idx = Matrix[Idx][(D[Idx]()) ? 0:1];

Step++;

}

std::cout << "----------------------------------------------------------------\n";

// Эмуляция восстановления в точке перед Proc-4 и продолжение

Continue = true;

Step = 9;

Idx = 3;

A = {3, 3 ,14, 1};

while(Continue) {

Print();

P[Idx]();

Idx = Matrix[Idx][(D[Idx]()) ? 0:1];

Step++;

}

std::cout << "----------------------------------------------------------------\n";

// использование прекрасного оператора GOTO!

label: if (true == false) goto label;

return 0;

}

Сохранение и восстановление состояния обработки

Majestio — Sat, 17 Sep 2022 20:46:19 +0000

Majestio: Ну что, уважаемые, вижу - все кто мог участвовать, уже смогли. Перечислю тех, кто хотел бы поучаствовать, но не с мог по причине запарок на работе, или отсутствием времени по иным причинам:

Про остальных - не знаю. Поэтому, считаю, что пора "вскрываться" :yes:

Пароли к архивам

Победила дружба!

И спасибо всем за участие, особенно порадовал korvin многообразием вариантов. Што-то смотрю мне OCaml немного приглянулся :rolleyes: Ну а выводы, надеюсь, всем понятны - никуда с помощью GOTO "впрыгивать" не нужно, равно как и городить многовложенных циклов, коль впереди маячат долгие пересчеты с сохранением состояний. Будет просто супер, если каждый из участвующих в отдельном сообщении соберет все свои варианты, но уже в текстовом виде под спойлер, а рядом выложит ссылку исполнения в онлайн компиляторе.

Peace! :victory:

Сохранение и восстановление состояния обработки

Wound — Sat, 17 Sep 2022 19:18:44 +0000

Wound:

Цитата D_KEY @ 17.09.22, 19:14

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

Ты с этим не согласен - это твое субъективное мнение или объективное? Если это твое субъективное мнение, то ты прав, потому что ты там что то используешь, что в принципе тебя может от этого спасти(с другой стороны конструкции такого плана, которые могут встретится в каких нибудь сторонних библиотеках - нужно как то исключать?). Но кроме тебя - еще полно людей, которые не используют то, что ты там у себя используешь, и объективно - то что ты приводишь, это не аргумент. Хотя применительно к тебе - аргумент да. Но мы не тебя же обсуждаем.
А то тебя послушать - так при нормальной организации работы, при нормальных знаниях ЯП, и тд. вообще будет все в шоколаде, но на практике - это не так.

Добавлено 17.09.22, 19:30
Ну и к слову - я на такие баги натыкался, когда вместо сравнения, было присваивание, причем натыкался случайно, и не один раз, в древнем, как говно мамонта коде, на тех же плюсах.

Сохранение и восстановление состояния обработки

D_KEY — Sat, 17 Sep 2022 19:14:37 +0000

D_KEY: Wound, я спорил с конкретным тезисом о том, что такую ошибку легко допустить в C++. Я с этим не согласен, потому что при нормальной организации работы, тебе даст по рукам уже компилятор.
Ни с чем другим я не спорил.

Сохранение и восстановление состояния обработки

Wound — Sat, 17 Sep 2022 19:08:27 +0000

Wound:

Цитата D_KEY @ 17.09.22, 18:54

Я без -Werror уже несколько лет не работаю. Впрочем, еще и статические анализаторы подключаю.

А те варнинги от которых в принципе избавится не возможно, ты давишь директивами #pragma :lol:
Аргументы поперли просто жесть. Да какая разница с чем ты там работаешь или нет? Мы обсуждаем твою личность тут или чего? Я goto в принципе не использую, и никогда в жизни у меня даже не возникало ни желания, ни мысли его использовать на работе(разве что только в исследовательских целях, дома когда изучал ЯП). Значит все в мире должны перестать его тоже использовать? Я верно понял твою логику?

Добавлено 17.09.22, 19:11
И вообще goto рудимент и пережиток прошлого. В тех языках например, где нет конструкции break в циклах for - его еще можно оправдать, а именно там он как бы и уместен, чтоб выпрыгивать досрочно из цикла, и то в тех же языках - его можно заменить while'ом, и никаких goto не нужно. А в высокоуровневых языках, я даже не могу представить где бы он мог бы понадобиться.

Добавлено 17.09.22, 19:13
Разве что писать спагетти-код, и доказывать окружающим, что теперь я в этом вижу какую то блоксхему...

Сохранение и восстановление состояния обработки

D_KEY — Sat, 17 Sep 2022 18:54:07 +0000

D_KEY:

Цитата Wound @ 17.09.22, 17:24

Компилятор выдаёт варнинг, а не ошибку

Я без -Werror уже несколько лет не работаю. Впрочем, еще и статические анализаторы подключаю.

Сохранение и восстановление состояния обработки

Wound — Sat, 17 Sep 2022 17:55:41 +0000

Wound:

Цитата korvin @ 17.09.22, 17:25

C/C++-проблемы. Заметь, ни один мой вариант, не использует эти языки.

Да, в плюсах это наследие от Си. В тех же шарпах это не законная конструкция и будет ошибка компиляции

Сохранение и восстановление состояния обработки

korvin — Sat, 17 Sep 2022 17:25:54 +0000

korvin: Ещё одна, альтернативная, версия на Ocaml:
majestio_machine_alt.ml.zip (, : 106)

И чисто функциональная версия на Haskell:
Majestio.hs.zip (, : 86)

Добавлено 17.09.22, 17:31

Цитата Wound @ 17.09.22, 17:24

Компилятор выдаёт варнинг, а не ошибку, т. к. это вполне себе законная конструкция.

C/C++-проблемы. Заметь, ни один мой вариант не использует эти языки.

Сохранение и восстановление состояния обработки

Wound — Sat, 17 Sep 2022 17:24:30 +0000

Wound:

Цитата D_KEY @ 17.09.22, 16:52

Это не только статические анализаторы, это уже компиляторы давно отлавливают

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

Сохранение и восстановление состояния обработки

D_KEY — Sat, 17 Sep 2022 16:52:34 +0000

D_KEY:

Цитата Wound @ 17.09.22, 14:32

ты в if'возьмешь провтыкаешь и вместо какого нибудь == напишешь присваивание(в плюсах как нехер делать)

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

Добавлено 17.09.22, 16:55

Цитата Majestio @ 17.09.22, 03:56

Очень хочу дождаться участия ... D_KEY, они ведь тут подбрасывали в начале идеи

Ну поговорку про разговоры и мешки ты знаешь :D
У меня сейчас полный завал дел и на работе и вообще в жизни, так что не смогу.

Сохранение и восстановление состояния обработки

Wound — Sat, 17 Sep 2022 14:32:12 +0000

Wound:

Цитата korvin @ 17.09.22, 14:21

Юнит-тесты? Не, не слышал.

Во первых причем тут юнитесты? У тебя будет чуть сложнее условие, ты в if'возьмешь провтыкаешь и вместо какого нибудь == напишешь присваивание(в плюсах как нехер делать), и потом сиди отлаживай своими юниттестами свою портянку, они тебя в этом случае не спасут.
Ты там недавно мне втирал про стектрейсы с DI, откуда ты их мог видеть, если у тебя контраргумент против отладки - Юнит-Тесты? :lol: Я ж так понимаю ты никогда не отлаживался, все юнит-тестами :rolleyes:

Цитата korvin @ 17.09.22, 14:21

Ты ничего не понял и всё испортил.

Нет, я прекрасно все понял. Ты взял эталонный спагетти-код, и просто захерачил 3 конструкции в одну строчку однотипно, чтоб этот трешак - более менее можно было понять. Даже у условных любителей goto, которые не брезгуют его применять, есть правила. И одно из них - прыгать можно на метку вперед, назад - это уже из серии говнокода, даже среди поклонников goto. А у тебя как раз тот случай, когда в зависимости от условия мы будем прыгать непойми куда, либо вперед, либо назад, за что собственно и критикуют goto, и предсказать выполнение программы, без ее отладки - зачастую затруднительно. Это даже затруднительно сделать глядя на твой код. Т.к. тут 4 метки, 4 условия(if/else), 8 прыжков, и код не тривиальный, т.к. ты несколько конструкций включая if/else в одну строку свернул(такое в основном студенты любят делать), что снижает читабельность и понимание кода.

Так что кончай прикрывать этот спагетти-код, каким то сомнительными аргументами.

Добавлено 17.09.22, 14:34
Все эти goto вполне себе могут быть оправданы в низкоуровневых яп , типа асма, да хоть те же си, где банально нет интструментов и смысла городить всякую архитектуру в стиле ООП или еще каком.

Сохранение и восстановление состояния обработки

korvin — Sat, 17 Sep 2022 14:21:04 +0000

korvin:

Цитата Wound @ 17.09.22, 05:51

которые потом еще попробуй пойди отладь

Юнит-тесты? Не, не слышал.

Цитата Wound @ 17.09.22, 05:51

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

Ты ничего не понял и всё испортил.

Сохранение и восстановление состояния обработки

Majestio — Sat, 17 Sep 2022 14:05:02 +0000

Majestio: Спасибо korvin и Wonder за обсуждение - вы меня вдохновили на новую версию!

Wonder, отдельный респект - он мне в личку раскрыл свои исходники. И я подсмотрел у него некоторые профессиональные решения - но пришлось использовать оператор goto :lol:
Прилагаю вторую версию, добавил изящества 80 лвл.

majestio_goto.cpp.7z (, : 96)

Сохранение и восстановление состояния обработки

Wound — Sat, 17 Sep 2022 05:51:36 +0000

Wound:

Цитата korvin @ 16.09.22, 23:18

если оно отображена в коде как есть?

Вот так оно будет к слову выглядеть, если переписать по нормальному, а не бабочек рисовать кодом, которые потом еще попробуй пойди отладь:

int main()

{

PROC_1 :

process_1() ;

if (decision_1())

goto PROC_4 ;

else

goto PROC_3 ;

PROC_2 :

process_2() ;

if (decision_2())

goto PROC_3 ;

else

goto PROC_4 ;

PROC_3 :

process_3() ;

if (decision_3())

goto PROC_2 ;

else

goto PROC_1 ;

PROC_4 :

process_4() ;

if (decision_4())

goto EXIT;

else

goto PROC_2 ;

EXIT:

return 0;

}

Очень все ясно и понятно, решение просто космос. :ph34r:

Добавлено 17.09.22, 06:00
Я тут даже чутка отформатировал отступы для меток, чтоб оно хоть как то полегче понималось. И это самый простейший случай!

Сохранение и восстановление состояния обработки

Majestio — Sat, 17 Sep 2022 03:56:52 +0000

Majestio:

Цитата Qraizer @ 16.09.22, 23:42

к тому времени конкурс уже будет закрыт, там goro не будет.

korvin и Wound по красоте зарубились! :lool:

Очень хочу дождаться участия ЫукпШ, OpenGL (но у него проблемсы), D_KEY, они ведь тут подбрасывали в начале идеи. Ну и вскроем пароли 8-)

Сохранение и восстановление состояния обработки

korvin — Sat, 17 Sep 2022 00:39:06 +0000

korvin:

Цитата Qraizer @ 16.09.22, 23:42

всем известный паттерн.

Что за паттерн-то?

Сохранение и восстановление состояния обработки

Wound — Fri, 16 Sep 2022 23:42:19 +0000

Wound:

Цитата korvin @ 16.09.22, 23:18

Странный ты, наплодил себе классов, теперь без сгенерированной диаграммы не можешь разобраться в коде )

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

Добавлено 16.09.22, 23:44

Цитата Qraizer @ 16.09.22, 23:42

Сосбсна, в этих случаях goto как раз и выручает. Я понимаю, что это не вполне интуитивно, но в исходном коде goto появился ровно по причине внезапно изменившегося ТЗ. Majestio вас некисло так потроллил, сформулировав ТЗ так, что у вас все вводные сразу на руках. Уверяю, в рамках его условия, если я и выложу код, хотя боюсь, к тому времени конкурс уже будет закрыт, там goro не будет.

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

Сохранение и восстановление состояния обработки

Qraizer — Fri, 16 Sep 2022 23:42:13 +0000

Qraizer: Majestio, кажись, я слегка погорячился, прованговав всем известный паттерн.

Цитата Wound @ 16.09.22, 21:30

Суровая реальность когда система постоянно расширяется, и дополняется. Выдвигают новые условия, новые фичи и т.д.

Сосбсна, в этих случаях goto как раз и выручает. Я понимаю, что это не вполне интуитивно, но в исходном коде goto появился ровно по причине внезапно изменившегося ТЗ. Majestio вас некисло так потроллил, сформулировав ТЗ так, что у вас все вводные сразу на руках. Уверяю, в рамках его условия, если я и выложу код, хотя боюсь, к тому времени конкурс уже будет закрыт, там goro не будет.

Сохранение и восстановление состояния обработки

Wound — Fri, 16 Sep 2022 23:29:23 +0000

Wound:

Цитата korvin @ 16.09.22, 22:28

Судя по этой диаграмме все ProcessN обрывают выполнение программы.

Вообще это показаны вызовы. Что откуда вызывается. У тебя на блок схеме(и в условии задачи так же) - решения(DecisionN) - в зависимости от результата(true/false), который сделал процесс, определяют какой процесс будет вызван следующим. Но сам процесс - никак не участвует в передаче управления кому либо, он лишь выполняет некие операции. Вот и получается что на схеме показаны вызовы от решений(Decision), а стрелки от процессов, всегда направлены на соответствующее процессу решение. Процес1 всегда ссылается на решени1, Процесс2 на решение2, процес3 на решение3 и т.д. Поэтому странно считать что ProcessN - что то там обрывает. Он не обрывает выполнение программы, он просто ничего не вызывает, и ни накого не ссылается, просто выполняет определенную операцию и все.

Добавлено 16.09.22, 23:36

Цитата korvin @ 16.09.22, 23:18

А зачем мне «восстанавливать схему», если оно отображена в коде как есть?

Во первых в твоем этом коде уже можно запутаться, ты помнишь свой аргумент про то, сколько человек может вещей в уме держать одновременно? У тебя тут как минимум 4 метки и 4 процесса, перемешанные в условиях, что уже ломает общую картину, а ведь это только 4 процесса! Если их тут будет даже не 50, а еще столько уже - это уже будет нечитаемое говно, даже с учетом твоего форматирования.
Потом, то что ты метку, вызов функции, потом условный оператор вместе с телом зарядил в одну строчку - это вообще отдельный лол. Потом эту шнягу такой сохраняешь, а какая нибудь падла типа IDE, или еще какой нибудь штуки, неверно раздуплилась с табами в перемешку с пробелами, и получилась каша, снова форматируй. :D
Потом ты взял эталонный спагети код, отформатировал его - чтоб визуально не наблюдать этот звиздец, и выдаешь это за ахеренное архитектурное решение. Но в нем даже при 4-рех процессах, уже глаза разбегаются!

Сохранение и восстановление состояния обработки

korvin — Fri, 16 Sep 2022 23:18:14 +0000

korvin:

Цитата Wound @ 16.09.22, 22:43

А теперь ты покажи, как ты будешь востанавливать изначальную блоксхему из всех этих goto, особенно в каких нибудь плюсах.
Вангую щас полетят "аргументы" в стиле - гляну на код, закрою глаза и сразу в мозгу схема нарисуется

А зачем мне «восстанавливать схему», если оно отображена в коде как есть?

int main()

{

PROC_1 : process_1() ; if (decision_1()) goto PROC_4 ; else goto PROC_3 ;

PROC_2 : process_2() ; if (decision_2()) goto PROC_3 ; else goto PROC_4 ;

PROC_3 : process_3() ; if (decision_3()) goto PROC_2 ; else goto PROC_1 ;

PROC_4 : process_4() ; if (decision_4()) goto EXIT ; else goto PROC_2 ;

EXIT:

return 0;

}

Странный ты, наплодил себе классов, теперь без сгенерированной диаграммы не можешь разобраться в коде )

Сохранение и восстановление состояния обработки

Wound — Fri, 16 Sep 2022 22:43:56 +0000

Wound:

Цитата korvin @ 16.09.22, 22:28

И что?

Ничего. Просто это означает что у меня из готовых классов, хоть даже их будет 50, проще будет востановить изначальную схему, чем у тебя с goto.

Цитата korvin @ 16.09.22, 22:28

Ужас какой. А вот эти *Context — они чему соответствуют на изначальной схеме? Судя по этой диаграмме все ProcessN обрывают выполнение программы.

Это базовая диаграмма на всякий шлак, не нужное можно выбросить и оставить только нужное. Расположить как тебе нравится.
Ужас будет когда твой switch/goto кто то будет разгребать. Вот там да - будет ужас.

А например, если выкинуть весь вспомогательный шлак и отфильтровать не нужное, то в сухом остатке останется вот такая схема:

Скрытый текст

scheme2.jpg (, : 254)

Добавлено 16.09.22, 22:46
На картинке это конечно херово показывать, но в IDE, я сразу могу ткнуть кнопку код, и тогда, когда я тыкну на ноду Decision, мне сразу откроется ее код, в котором идет условие. Т.е. я находу могу понять когда оно будет ссылаться на один процес, а когда на другой. Соответственно схема у меня уже готовая, даже разгребать ничего не нужно.

Добавлено 16.09.22, 22:53
А теперь ты покажи, как ты будешь востанавливать изначальную блоксхему из всех этих goto, особенно в каких нибудь плюсах.
Вангую щас полетят "аргументы" в стиле - гляну на код, закрою глаза и сразу в мозгу схема нарисуется :lol:

Сохранение и восстановление состояния обработки

korvin — Fri, 16 Sep 2022 22:28:44 +0000

korvin:

Цитата Wound @ 16.09.22, 22:14

если ты заметил у меня возвращается там не просто строка, а поле класса

И что?

Цитата Wound @ 16.09.22, 22:14

Вот пример того что сгенерировалось на том, что уже там есть:

Сохранение и восстановление состояния обработки

Wound — Fri, 16 Sep 2022 22:14:33 +0000

Wound:

Цитата korvin @ 16.09.22, 22:09

Попробуй добавить ещё 45 процессов и ветвлений (decision), и сгенерировать схему. Можешь приложить скриншот сюда — посмотрим.

Ну во первых мне честно лень добавлять еще 45 процессов. Это тупая копипаста получится. Схема от этого особо не изменится, если ты заметил у меня возвращается там не просто строка, а поле класса, генератор построит примерно такую же блоксхему как на твоем скрине, т.к. каждый объект решения будет ссылаться на соответствующие процессы, единственное что там не будет писать Yes/No, но связи понятны будут.
Вот пример того что сгенерировалось на том, что уже там есть:

Скрытый текст

scheme.jpg (, : 271)

Добавлено 16.09.22, 22:15

Цитата korvin @ 16.09.22, 22:09

Да при том, что спагеттность зависит не от того, используешь ты goto или объекты, а от плохой структурированности архитектуры приложения.

Как показывает практика и мой личный опыт, практически в 99% случаев код с goto - представляет из себя спагети-код.

Добавлено 16.09.22, 22:16
Еще в Сях так или иначе goto можно оправдать когда надо вылететь из -за МКАДа куда то в конец функции на Cleanup, и то это не всегда оправдано. А уж в плюсах - этот goto нахрен не упал, ИМХО.

Сохранение и восстановление состояния обработки

korvin — Fri, 16 Sep 2022 22:09:03 +0000

korvin:

Цитата Wound @ 16.09.22, 21:53

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

Да при том, что спагеттность зависит не от того, используешь ты goto или объекты, а от плохой структурированности архитектуры приложения. Попробуй добавить ещё 45 процессов и ветвлений (decision), и сгенерировать схему. Можешь приложить скриншот сюда — посмотрим, сколько там будет стрелок и их пересечений.

Сохранение и восстановление состояния обработки

Wound — Fri, 16 Sep 2022 21:53:40 +0000

Wound:

Цитата korvin @ 16.09.22, 21:46

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

Ну так вот тебе и ответ откуда там 92 килобайта. Уж извини не я делал плюсы и всякие сишарпы, но с другой стороны и руками я его не писал, IDE все само генерило.

Добавлено 16.09.22, 21:55

Цитата korvin @ 16.09.22, 21:50

Что, никогда стектрейсы фреймворков с DI-контейнерами не разгребал, например? )

Сохранение и восстановление состояния обработки

korvin — Fri, 16 Sep 2022 21:50:17 +0000

korvin:

Цитата Wound @ 16.09.22, 21:45

Да ну, какая беготня? Я если честно не понимаю твоих аргументов.

Что, никогда стектрейсы фреймворков с DI-контейнерами не разгребал, например? )

Сохранение и восстановление состояния обработки

Wound — Fri, 16 Sep 2022 21:50:03 +0000

Wound:

Цитата korvin @ 16.09.22, 21:46

Что там искать? Там код десять строчек. А искать ту реализацию метода интерфейса, которая действительно была вызвана, — вот это настоящее приключение.

Да то там искать, как не вижу goto, а я довольно редко его встречаю, в основном в индусских примерах WinAPI на MSDN'e, так сидишь смотришь - где там этот индус метки понаставил, и каким хером я туда попаду, и почему я не попаду в другое место. И вроде кода 40 строк, а сидишь как олень метки эти ищешь. И про какую ту реализацию метода ты говоришь? В чем у тебя проблемы с поиском методов я не понимаю?

Сохранение и восстановление состояния обработки

korvin — Fri, 16 Sep 2022 21:46:39 +0000

korvin:

Цитата Wound @ 16.09.22, 21:30

Искать метку глазами, в незнакомом коде - то еще удовольствие

Что там искать? Там код десять строчек. А искать ту реализацию метода интерфейса, которая действительно была вызвана, — вот это настоящее приключение.

Добавлено 16.09.22, 21:48

Цитата Wound @ 16.09.22, 21:30

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

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

Сохранение и восстановление состояния обработки

Wound — Fri, 16 Sep 2022 21:45:16 +0000

Wound:

Цитата korvin @ 16.09.22, 21:41

Где из пять? Их четыре, stop/default — не процесс. И не нужно понимать всё буквально.

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

Цитата korvin @ 16.09.22, 21:41

Нет, не превращается. Беготня по классам-родителям-наследникам туда-сюда — вот настоящее спагетти =)

Да ну, какая беготня? Я если честно не понимаю твоих аргументов.

Добавлено 16.09.22, 21:46

Цитата korvin @ 16.09.22, 21:41

Нет, чтобы код писать понятный, лучше добавить костыль, да?

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

Сохранение и восстановление состояния обработки

korvin — Fri, 16 Sep 2022 21:41:44 +0000

korvin:

Цитата Wound @ 16.09.22, 21:30

Ну тогда switch тут вообще не катит, последние же иследования говорят что 4+- 1, а у тебя аж 5 процессов в исходной задаче, вместе с default - 6

Где из пять? Их четыре, stop/default — не процесс. И не нужно понимать всё буквально.

Добавлено 16.09.22, 21:43

Цитата Wound @ 16.09.22, 21:30

Много ума не надо, а сложнее в том, что все это превращается в спагети-код.

Нет, не превращается. Беготня по классам-родителям-наследникам туда-сюда — вот настоящее спагетти =)

Добавлено 16.09.22, 21:44

Цитата Wound @ 16.09.22, 21:30

Ну и плюс в MSVS есть диаграмма классов, которую можно сгенерировать из уже написаной проги.

Нет, чтобы код писать понятный, лучше добавить костыль, да?

Сохранение и восстановление состояния обработки

Wound — Fri, 16 Sep 2022 21:30:11 +0000

Wound:

Цитата korvin @ 16.09.22, 21:15

Это и есть нарушение принципа YAGNI. Это «потом расширять» может никогда не наступить и в итоге у тебя overengineering на ровном месте.

Судя по описанию в вики, принцип YAGNI нарушается тогда, когда ты делаешь то, что тебе нахер не упало, но по твоим ощущениям в будущем может пригодится. Например в моем подходе таких функций/методов нет. Там все нужно. А то тебя щас послушаешь, так выйдет так что и принципы SOLID противоречат YAGNI, и вообще все надо писать в main, спагети-кодом, а потом когда заказчик прибежит с очередными требованиями - срочно надо все рефакторить и обязательно снова спагети-кодом, а как иначе? Зачем усложнять да?

Цитата korvin @ 16.09.22, 21:15

Более-менее есть:

Ну тогда switch тут вообще не катит, последние же иследования говорят что 4+- 1, а у тебя аж 5 процессов в исходной задаче, вместе с default - 6 :D

Цитата korvin @ 16.09.22, 21:15

1) он не отдельный: после него идёт проверка по результатам которой выбирается следующий процесс — вот тебе и связь. Только ты раскидал её по разным файлам. Теперь, чтобы восстановить картину, тебе понадобится сгенерировать какую-нибудь диаграмму классов/зависимостей, а ля UML, вместо того, чтобы сразу написать наглядный код.

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

Цитата korvin @ 16.09.22, 21:15

2) ничто не мешает мне вынести реализации процессов в отдельные процедуры, что я ± и сделал в своих примерах, сохранив при этом общую схему в одном месте, прям как на картинке.

Ну так после ивента ТС скажет, а давайте теперь еще 45 процессов добавим, чтоб 50 получилось. И вся твоя наглядность рухнет, потому что как ты там выше написал чел больше 4 вещей одновременно воспринимать не может. А у тебя их 50.

Цитата korvin @ 16.09.22, 21:15

Падающие на датацентры метеориты — суровая реальность?

Цитата korvin @ 16.09.22, 21:15

Там нечем выносить. Применение goto там ничем не отличается от switch/case.

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

Цитата korvin @ 16.09.22, 21:15

Архитектура «диктует» решение, а не наоборот.

Вообще не понял о чем ты тут. Я написал что - я не видел что сделал ТС. И не могу прогнозировать придется ему там все переписывать с нуля, или просто добавить еще с десяток меток.

Добавлено 16.09.22, 21:31

Цитата korvin @ 16.09.22, 21:15

Ты сам себе противоречишь: определись, «много ума не надо» или «сложнее».

Много ума не надо, а сложнее в том, что все это превращается в спагети-код.

Цитата korvin @ 16.09.22, 21:15

Твоё решение — 92 килобайта, решение ТС — меньше килобайта. Расскажи ещё раз про сложность.

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

Добавлено 16.09.22, 21:41

Цитата korvin @ 16.09.22, 21:15

Теперь, чтобы восстановить картину, тебе понадобится сгенерировать какую-нибудь диаграмму классов/зависимостей, а ля UML, вместо того, чтобы сразу написать наглядный код.

Ну и плюс в MSVS есть диаграмма классов, которую можно сгенерировать из уже написаной проги. Я вот ради прикола сгенерировал. Прекрасно востановилась схема ТС. Могу скинуть скрин если нужно.

Сохранение и восстановление состояния обработки

korvin — Fri, 16 Sep 2022 21:15:58 +0000

korvin:

Цитата Wound @ 16.09.22, 20:57

закладывается с таким прицелом, чтоб это потом проще было бы расширять и сопровождать.

Цитата Wound @ 16.09.22, 20:57

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

Более-менее есть:

Цитата

Каждый программист знает, что возможности нашего мозга не безграничны. Есть ограничение на количество вещей, о которых мы можем думать. Это наш рабочий лимит памяти. Есть старый миф о том, что человек может держать в памяти одновременно 7±2 объектов. Это называется "Магическое число семь" и оно на самом деле не очень точное. Последние исследования говорят о числе 4±1, а то и меньше. В любом случае — количество идей, которые мы можем держать одновременно в голове, весьма ограниченно.

Цитата Wound @ 16.09.22, 20:57

У меня точно жопы не будет, т.к. каждый процесс - рассматривается как отдельная сущность.

Но
1) он не отдельный: после него идёт проверка по результатам которой выбирается следующий процесс — вот тебе и связь. Только ты раскидал её по разным файлам. Теперь, чтобы восстановить картину, тебе понадобится сгенерировать какую-нибудь диаграмму классов/зависимостей, а ля UML, вместо того, чтобы сразу написать наглядный код.
2) ничто не мешает мне вынести реализации процессов в отдельные процедуры, что я ± и сделал в своих примерах, сохранив при этом общую схему в одном месте, прям как на картинке.

case 1:

process1();

state = decision1() ? 4 : 3;

break;

Ну а мой пример на Go позволяет так же всё довольно легко расщирять, при желании/необходимости и/или сохранять схему в одном месте.

Цитата Wound @ 16.09.22, 20:57

Так это не что то из ряда вон выходящее, а вполне себе суровая реальность.

Падающие на датацентры метеориты — суровая реальность?

Цитата Wound @ 16.09.22, 20:57

Ну разве что если сидеть выносить себе мозги этим goto...

Там нечем выносить. Применение goto там ничем не отличается от switch/case.

Цитата Wound @ 16.09.22, 20:57

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

Архитектура «диктует» решение, а не наоборот.

Добавлено 16.09.22, 21:18

Цитата Wound @ 16.09.22, 20:57

Ну и плюс расписать всю его схему на if/else или switch|case - много ума не надо(это даже не интересно), я сразу же отказался от этого варианта, т.к. это сложнее

Ты сам себе противоречишь: определись, «много ума не надо» или «сложнее».

Цитата Wound @ 16.09.22, 20:57

это сложнее, чем тот подход, который например, я выбрал.

Твоё решение — 92 килобайта, решение ТС — меньше килобайта. Расскажи ещё раз про сложность.

Сохранение и восстановление состояния обработки

Wound — Fri, 16 Sep 2022 20:57:28 +0000

Wound:

Цитата korvin @ 16.09.22, 20:37

Никакой портянки.

Портянка и спагети-код, к бабке не ходи.

Цитата korvin @ 16.09.22, 20:37

Вот когда требования изменятся, тогда и будешь тратить время на рефакторинг. YAGNI

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

Цитата korvin @ 16.09.22, 20:37

Рефакторить нужно вовремя

Цитата korvin @ 16.09.22, 20:37

Если у тебя 50 процессов, никак не сгруппированных в подсистемы, то у тебя в любом случае будет жопа, хоть switch/case'ом пиши, хоть объектами, хоть наглядную схему черти: запутаешься в переходах от объекта к объекту, и общая картина у тебя не соберётся в голове.

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

Цитата korvin @ 16.09.22, 20:37

А если метеорит упадёт на датацентр?

Так это не что то из ряда вон выходящее, а вполне себе суровая реальность.

Цитата korvin @ 16.09.22, 20:37

Тут ничего не пролетает.

Ну разве что если сидеть выносить себе мозги этим goto...

Цитата korvin @ 16.09.22, 20:37

ТСу надо пересмотреть архитектуру проекта в первую очередь. А goto тут не при чём.

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

Добавлено 16.09.22, 21:00
Ну и плюс расписать всю его схему на if/else или switch|case - много ума не надо(это даже не интересно), я сразу же отказался от этого варианта, т.к. это сложнее, чем тот подход, который например, я выбрал. Про другие подходы - я не говорю, т.к. не видел.