Lab 2

[the-homeless-god]

– What's immutability? Provide a few examples.
– Describe the monad. Provide a few examples.
– Provide a few examples for endless machines.
– What's difference between OOP and FP?
– Provide examples for tasks that can be solved only with FP.
– How do you understand carrying?
– Example of idempotency in real life
– What's daemon in *nix systems?

[Rey1147]

1. Иммутабельность – это концепция, которая подразумевает, что состояние объекта после его создания не будет изменено. Вместо модификации существующего объекта создаётся его копия, которая используется для дальнейшего преобразования.
   Банк может создать купюры с новым дизайном. Купюры со старым дизайном не перестанут существовать
2. Монада это способ управления вычислениями в определённом контексте (например, обработка ошибок или асинхронных задач). Она помогает перекидывать данные через цепочку операций, сохраняя контекст
   Команда .then() это операция, которая получает результат предыдущего шага и передаёт его дальше, как монада
3. Бесконечный цикл (while (true) {}). Машина Тьюринга имеет потенциально бесконечную ленту, на которой она читает и записывает символы. Если программа не содержит условия останова, машина будет работать бесконечно
4. ФП основано на чистых функциях, которые не изменяют состояние, а просто принимают данные и возвращают новые. В отличие от ООП, где объекты хранят и изменяют своё состояние
5. Каррирование функции. В ООП для такого пришлось бы создавать класс с методом
   Генерация бесконечного ряда Фибоначчи. В ООП пришлось бы хранить изменяемое состояние
6. Каррирование - возможность произвольного задания контекста для функции. Это процесс превращения функции, которая принимает несколько аргументов, в серию функций, каждая из которых принимает по одному аргументу и возвращает новую функцию
7. Первый раз включили лампочку — свет включился. Каждый последующий раз, пока лампочка уже включена, вы ничего не измените, свет не станет ярче, он остаётся включённым
8. Демон в *nix-системах это фоновый процесс, который выполняется без взаимодействия с пользователем. Он запускается при старте системы или по запросу и выполняет задачи, такие как обработка сетевых запросов или управление сервисами

[kagam1i]

Бялясова Елена 3/147

1. Иммутабельность— это когда объект после создания нельзя поменять. Если нужно что-то изменить, создаётся новый объект, а старый остаётся таким, каким был.
   Примеры:
   Надпись на бумаге: мы не можем изменить то, что уже написано, только если возьмем новый листок и напишем заново.
   История в браузере: мы не можем изменить запись об уже посещенном сайте.
2. Монада – способ обернуть данные, для более удобной работы ними, избегая ошибок.
   Примеры:
   Сайт, требующий регистрацию перед доступом к контенту
   Лекарства с инструкцией по применению
3. Майнинговые компьютеры, хостинг сайта, система электроснабжения
4. ООП - это стиль программирования, где всё строится вокруг объектов, а ФП– это стиль, где всё строится вокруг функций, которые не меняют данные, а обрабатывают их.
5. Вычисление факториала числа, выборка четных чисел из списка
6. Преобразование функции с любым количеством аргументов в функцию только с одним аргументом.
7. Если мы запрели дверь на ключ, то еще один поворот ключа не сделает ее «более закрытой»
8. Программа, которая работает в фоновом режиме и делает какую-то работу без участия пользователя. Она запускается автоматически при включении компьютера и работает постоянно, пока ее не остановят.

[Ygolechek]

1. Иммутабельность — это, по сути, неизменяемость. Если состояние объекта = неизменяемое, то мы не можем изменить его после создания. Можно привести несколько примеров из реальной жизни. Например, ДНК. Она содержит генетический код организма и является неизменной. Она передаётся от родителей к потомству без изменений. Снежинки: каждая снежинка имеет уникальную и неизменяемую кристаллическую структуру.
2. Монада — это набор функций, которые преобразуют значения в определённый тип, представляющий вычисления. Например, с помощью функции можно преобразовать тип данных int в string или добавить элемент в список.
   3.В качестве примера можно привести природу, ведь она сама может рассматриваться как бесконечная машина, поскольку постоянно меняется и развивается, создавая бесконечное разнообразие форм и процессов. За бесконечную машину я бы принял фракталы, которые самоподобны, и при увеличении мы увидим бесконечное множество деталей фракталов.
   Круговорот воды в природе — тоже элементарный пример бесконечной машины. Цикл является непрерывным и повторяется снова и снова.
3. ООП-подход предполагает работу с объектами, а в ФП — с функциями. Объекты в ООП могут изменяться, как и их свойства, а в ФП данные не могут изменяться. В первом случае обязательно хранение данных, а во втором данные нигде не хранятся.
4. Выписать все дробные числа от 0 до 1. Или просто выписать все числа, находящиеся между двумя соседними целыми числами. Если хранить эти значения где-либо, то места не хватит, так как их бесконечное количество. Если хранить только в какой-то конкретной переменной, то с переменной может что-то случиться (в компьютер ударит молния), и данные изменятся или пропадут в какой-то момент. В данной ситуации ФП будет возвращать только само значение функции и нигде его не сохранять, а значит, будет работать непрерывно, пусть и до бесконечности (что, как ни странно, подтверждает, что это вообще будет работать).
5. Каррирование (currying) — это преобразование функции с множеством аргументов в набор вложенных функций с одним аргументом. Благодаря каррированию функцию можно вызывать последовательно, передавая данные по одному параметру. Функция не будет заполнена, пока не будут переданы все параметры.
6. Идемпотентность — свойство функции, при многократном применении которой к одному и тому же аргументу результат не отличается от результата однократного применения. Например, если мы опустим выключатель света 1 раз, то свет выключится, если мы выполним это действие ещё раз, то результат останется прежним
7. Демон в *nix-системах — это процесс, который работает в фоновом режиме и не требует взаимодействия с пользователем.

[MrLobzik]

Лобанов Дима 3/147

1. Иммутабельность - это свойство объекта, не позволяющее каким-либо способом изменить его состояние. Например, константы в программировании. Методы класса DataFrame из библиотеки pandas для Python: они возвращают изменённый DataFrame, но это не тот же самый объект, который был изначально. Первичный объект не подвергается изменениям, а действия метода применяются к возвращаемому.
2. Как я понял, монада - практически тоже самое, что и функторы, только в функциональном программировании. Исходя из этого основная функция монады - служить обёрткой для какой-либо функции (последовательности действий). При дальнейшем рассмотрении монады, заметно, что она по свойствам больше похожа на узел синтаксического дерева, который выполняет какую-то функцию и ссылается на другие узлы, являющиеся операндами функции. Примеры: функторы и лексические деревья
3. Любые вариации вечного двигателя, Машина Тьюринга, бесконечный автомат Мили
4. В ООП главной единицей программы являются объекты в то время, как в ФП - функции. ООП объединяет данные и поведение, ФП - разделяет. И самое главное - ссылочная прозрачность функций. Она обязательно для ФП. В ООП результат функции/метода может быть зависим от каких-либо глобальных состояний, в ФП - нет
5. Таких не знаю, задачи можно решить разными подходами. Разница только в том, что где-то код будет короче, чище, более лёгкий для тестирования, менее запутанный (из-за отсутствия множества связей между объектами) или более предсказуемый
6. Каррирование - техника, с помощью которой 1 функция с множеством аргументов преобразуется в последовательность множества функций с 1 аргументом
7. Дверь с датчиком движения. Когда кто-либо к нему подходит дверь открывается
8. Демон - это вид программ работающих в фоновом режиме, без прямого взаимодействия с пользователем. Обычно запускаются системой при старте. Например, программа ищущая сеть на телефоне (в сим-карте), GPS-трекер, мониторинг погоды

[notonafu]

1. Иммутабельность – свойство какого-либо объекта не изменять состояния после его создания. Модификация иммутабельного объекта приводит к созданию нового объекта, не изменяя старого. Пример: строки в Python, коммиты в Git.
2. Монада позволяет структурировать последовательность действий, когда каждое действие не только выдает результат, но и дополнительную информацию, или даже выполнение другого (конкретного) действия. Пример использования монады: логирование информации о выполнении каждого действия в консоль.
3. Машина Тьюринга с бесконечной лентой, вечный двигатель, фоновые сервисы ОС Windows (условно).
4. ООП – объекты и методы; возможность изменения данных после их создания. ФП – функции и переменные; невозможность изменения данных, цель – их обработка.
5. Доказательство научных теорем, рекурсии.
6. Каррирование – превращение функции с несколькими параметрами в последовательность функций с одним параметром.
7. Кнопка вызова лифта.
8. Фоновые процессы, помогающие ОС работать корректно и не требующие взаимодействия с пользователем.

[goutosama]

Чадов Сергей 3/147

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

2. Монада - принцип управления данными в соответствии с контекстом или же принцип позволяющий скрыть от пользователя часть кода, производимого над данными. Примеры: автоматическое логирование с помощью монад, функции map(), bind() в языках программирования Python и JavaScript, специальные объекты данных в фронтенд-фреймворках, заставляющие сайт перерисовываться при их изменении (как ref() в Vue)

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

4. Подходы объектно-ориентированного программирования и функционального различаются главенствованием одного из элементов - объектов или функций соответственно. Оба элемента подразумевают бесконечные возможности для описания и программирования каких-либо процессов, поэтому некоторые языки программирования сильно склоняются к одному из них: язык Java основан на ООП и продвигая идею, что "всё есть объект некоторого класса" и сохраняет объекты в своей памяти, а языки вроде Haskel подразумевают, что "всё есть функция" и не подразумевает какое-либо хранение состояний. Несмотря на то, как различается программирование и структура программ в этих разнополярных языках, я считаю, что разницы в выразительности программ в них нет и на них обоих можно запрограммировать что угодно.

5. Хотя я и слабо представляю как это выглядит, но интернет говорит, что только в функциональных языках программирования можно доказывать различные теоремы. В остальных практических случаях, я считаю, что любую задачу можно решить и на ООП подходе и на функциональном.

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

7. Идемпотентные операции: API сайта, выдающее один и тот же набор данных вне зависимости от количества вызовов (пока данные не обновятся), операции присваивания переменным значений, директивы для соединения кода в C (#include) добавляют код из файла только единожды.

8. Daemon - даемон, он же демон, программа, выполняющаяся в фоне без интерфейса (headless) и чаще всего запускающаяся вместе с системой, они работают в фоне и никак не показываются пользователю. Так как в Unix-системах общение между программами происходит через текстовые потоки, даемоны запускаются в своём отдельном терминале и могут только получать и отправлять текстовые потоки.

[Clearheadedtyt]

Никитин Кирилл 3/147

1. Неизменяемость - это свойство объектов, которые нельзя изменить после их создания. Любая модификация приводит к созданию нового объекта.
   Примеры:

• Книга. Вы не можете стереть напечатанный текст, но можете написать новую книгу с изменениями;
• Каменная статуя. Если вы хотите добавить деталь, нужно вырезать новую статую.

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

• Почтовый ящик. Вы кладете письмо в ящик → почтальон забирает его → доставляет адресату. Каждое действие происходит "внутри" системы (ящика).

3. Бесконечные машины (Endless Machines) - это процессы, которые работают без остановки.
   Примеры:

• Сердце человека бьется непрерывно, пока человек жив;
• Уличные фонари, которые автоматически включаются каждый вечер.

4. ООП фокусируется на объектах и их взаимодействии, а ФП — на функциях и преобразовании данных.
   ООП — как моделирование мира через сущности, ФП — как решение задач через математические вычисления.

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

6. Каррирование (currying) - это преобразование функции от многих аргументов в последовательность функций одного аргумента. Используется для частичного применения функций (например, создание шаблонных функций).

7. Идемпотентность — свойство операции, при котором повторное выполнение не меняет результат.
   Пример:

• Кнопка лифта. Если вы нажмете кнопку вызова лифта 10 раз, лифт приедет только один раз. Повторные нажатия не ускорят его и не изменят конечный результат.

8. Демон в *nix-системах - это фоновый процесс-помощник.

[GitSwaggCat]

Новосёлов Николай 3/147

1. Неизменяемость - свойство объекта не поддаваться изменениям из вне. Например, константы в физике.
2. Монада - способ комбинации функций в разной последовательности при этом никак не изменяя контекст
3. Вечный двигатель, Машина Тьюринга, Рекурсивные машины
4. В ООП главной составляющей являются объекты-классы, а в ФП это функции. ООП объединяет данные в удобные структуры, а в ФП наоборот разделяет их для удобного и простого вычисления.
5. Подсчёт каких либо чисел.
6. Каррирование - Преобразование функции с множеством аргументов в функцию с лишь 1 аргументом
7. Кнопка запуска приложения
   "Безумие — это точное повторение одного и того же действия раз за разом в надежде на изменение"
8. Демон в системах nix - демон, который делает что-то в фоновом режиме без внешнего воздействия

[denisbochka]

Смолов Денис 3/147

1. Иммутабельность - свойство объекта, которое означает, что его состояние нельзя изменить после создания. Любые изменения этого объекта создадут новый объект. Например: мы хотим изменить вкус чипсов twister с крабом, но уже существующие мы не можем изменить, поэтому будем делать уже новые с изменённым вкусом.
2. Монада - способ задания порядка выполняемых операций. Например с помощью try можно связать две функции, чтобы вторая вызывалась только при успешном завершении первой
3. Перечисление всего множества чисел; гравитация воздействует на нас везде и всегда, вне зависимости от того, где на планете мы находимся
4. В ООП данные и связанное с ними поведение объединяются в объекты. В ФП данные и поведение чётко разделены, а вместо объектов используются функции, которые принимают данные и возвращают результат
5. Обработка большого объёма данных, параллельные вычисления
6. Каррирование - преобразование одной функции с некоторым количеством аргументов в последовательность вложенных функций, которые имеют по одному аргументу
7. Кнопки Вкл/Выкл - сколько ни нажимай ничего другого они не сделают
8. Демоны в *nix-системах - фоновые программы, запускаемые самой системой без прямого взаимодействия с пользователем

[RedMarshall37]

Киселев Артем 3/147

1. Иммутабельность - это когда что-то нельзя изменить после создания.

К примеру, фактическое существование числа 7 нельзя изменить, что бы мы не делали.
Ну, или в программировании мы можем создать строку, к примеру, "Hello world!", и изменить ее мы не сможем. При попытке изменения мы просто создадим новую строку и ссылку на нее запишем в новую переменную

2. Монада. Я мог что-то не так понять, но, это концепция, в которой мы работаем с черным ящиком, не открывая его. К примеру, у нас есть монада, в который лежит число 5. Мы об этом не знаем, но можем попросить ее добавить к тому, что лежит в ней число 3. При том, что мы можем не знать, что именно там лежит. К примеру, вместо числа там могла быть пустота, и он мог бы вернуть нам или ошибку, или воспринимать ее как 0. Или может быть он создал-бы массив с 3 новыми элементами и вернул-бы нам их. Суть в том, что для нас это не важно. Мы просто сказали "Добавь к тому, что внутри тебя 3" и получили результат

3. Бесконечные машины — устройства, которые могут работать бесконечно.
   Примеры:

Бесконечный цикл в программе, который никогда не останавливается.
Наша реальность, в какой-то степени

4. Разница между ООП и ФП:ООП (объектно-ориентированное программирование) — это когда всё строится вокруг объектов, которые имеют состояние и поведение, в то время как в ФП всё строится вокруг функций, которые не изменяют состояние, а только возвращают новые данные

5. Задачи, которые могут быть решены только с помощью FP:

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

6. Каррирование — это превращение функции с несколькими аргументами в последовательность функций, каждая из которых принимает один аргумент. Например:
   Функция, в которой мы складываем a + b превращается в функцию add(a);add(b)

7. Идемпотентность — это когда повторение операции не меняет результат. Например, сколько бы раз ты ни нажал на кнопку лифта, он всё равно приедет только один раз.

8 daemon в nix — это программа, которая работает без участия пользователя. К примеру, системный процесс, который следит за обновлениями..

[EugeneWWolf]

3-147 Ермакова Ксения

Задание 1
Объект иммутабельный, когда нельзя изменять его состояние после его создания. Для "изменения" объекта нужно создать новый. Примеры: строки, кортежи в Питоне, различные типы данных в Хаскеле (в большинстве случаев). Из реальных объектов - паспорт.

Задание 2
Монада - это перенос функции с результатом выполнения в контекст другой функции с результатом выполнения. В качестве примера могу привести простой "калькулятор", у которого есть функции по типу square, cube, addOne (для простоты это функции, которые принимают один аргумент). И к этой штуке мне захотелось прикрутить логирование. Для этого можно создать тип numberWithLogs, который будет хранить в себе число и связанные с ним логи (чем больше операций будет происходить с числом, тем больше будет становиться лог). Теперь можно сделать так, чтобы функции мат. операций принимали на вход не просто number, а numberWithLogs (на выходе этих функций будет тоже соответственно numberWithLogs). Но это быстро становится неудобным, потому что при вложении операций друг в друга (например, square(square(5)) будет выводиться ошибка о том, что number не содержит в себе логов. К тому же каждая операция дублирует в себе код "соединения" новых логов с прошлыми, что при большом количестве кода станет катастрофой. Поэтому для было бы удобно предоставить такую штуку, которая будет перегонять number в "контекст" numberWithLogs для дальнейших операций с этим. Допустим, это будет функция wrapWithLogs. Тем самым при вызове square можно делать так: square(wrapWithLogs(5)). Затем, чтобы в теории не повторять логику соединения логов внутри каждой операции и в целом сделать код более простым и гибким в использовании, её можно вынести в отдельную функцию, которую можно назвать, например, runNumbersWithLogs. Она будет принимать на вход numberWithLogs, а также операцию над ним в виде функции, например, addOne, которая принимает на вход теперь просто number и возвращает numberWithLogs, ведь теперь ей не нужно соединять логи воедино, достаточно вернуть в логах и в результате только то, что она сделала без учёта тех логов, за которые она по сути не отвечает. В итоге runNumbersWithLogs применяет функцию с операцией на число ("достаёт" из numberWithLogs само число без логов и передаёт в соответствующую функцию по типу addOne), затем сама соединяет старый лог числа с новым (опять же достаёт его отдельно из numberWithLogs и лепит вместо) и в конце возращает уже "готовый" numberWithLogs.

В итоге этот пример я могу назвать монадой (все три компонента являются её составляющими: numberWithLogs, wrapWithLogs, runNumberWithLogs). Создаётся numberWithLogs, затем она даёт возможность "превратить" входные данные в numberWithLogs и выполняет любые заданные операции над numberWithLogs (и только над numberWithLogs, runNumberWithLogs не принимает простые строки, числа или что-то другое...), которые удовлетворяют определённым условиям (получают на вход 1 аргумент number) и возвращает в итоге numberWithLogs, который можно будет продолжать использовать в любом порядке с помощью runNumberWithLogs неограниченное количество раз (т. е. пока не закончится память под логи).

Задание 3
Могу привести в пример клеточный автомат по типу "Игры в жизнь" Конвея. Несмотря на простоту, там бесконечно много исходов, что делает данный автомат в теории бесконечным. Также бесконечным автоматом можно назвать состояние вселенной в каждый момент времени. Она постоянно расширяется, изменяется и её состояниям по сути нет конца.

Задание 4
В то время как в ООП "приветствуется" изменение состояние объектов, то есть там всё постоянно меняется и одна переменная может поменять одно (или все) из своих полей большое количество раз, то в ФП стараются максимально избегать изменения состояния объектов.

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

Задание 6
Каррирование - это возможность разделить функцию на вложенные. Например, на вход какой-нибудь функции выгулятьКота подаётся 2 аргумента: Кот и Таня. Мы можем разделить её на набор вложенных функций, которые принимают один аргумент. Тем самым вызов функции будет выглядеть не как выгулятьКота(Таня, Кот), а примерно как выгулятьКота(Таня)(Кот).

Задание 7
Идемпотентность - гарантия того, что при выполнении того или иного действия состояние объекта изменится только один раз. Дальнейшее повторение этой же операции не повлияет на его состояние. Например, регистрация пользователя является идемпотентной операцией. Как только он зарегистрировался хоть один раз, он не может завести новый аккаунт на эти же данные. Не важно, сколько раз он будет повторно нажимать на кнопку регистрации, его статус наличия в системе не поменяется и новые аккаунты создаваться не будут. Он будет постоянно видеть одну и ту же красную надпись про то, что этот пользователь уже зарегистрирован.

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

[Victor2004]

Пыжов 3/147

1. Иммутабельность (неизменяемость) - это свойство объекта, состояние которого не может быть изменено после создания.
   Пример: Договор после подписания не может быть изменён. Если нужно внести изменения, то требуется новый договор.

2. Монада - это абстракция для обработки значений и упрощения работы с последовательностями вычислений, она позволяет сделать код более чистым.

3. Вечный двигатель, бесконечные игры (игры у которых нет финиша или другой конечной цели).

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

5. Вычисление чисел фибоначчи или факториала, т. к. ФП хорошо подходит для рекурсивных алгоритмов.

6. Каррирование - это превращение функции которая принимает несколько аргументов, в последовательность функций, каждая из которых принимает один аргумент.

7. Нажатие кнопки "Включить" повторное нажатие кнопки не поменяет результат.

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

[Yasusuhi]

Панкова Алина 3/147

1. Иммутабельность — это свойство, когда объект остаётся в первозданном виде после его создания, а любые попытки внести изменения приводят к созданию нового объекта, а не модификации старого.
   Примеры:

1. Дошик — если раз приготовил, то к изначальному твердому виду его уже не вернуть
2. 100 рублей — нельзя превратить её в купюру большего номинала, но можно разменять на две по 50

2. Монада — грубо говоря, контейнер, в который можно что-то положить и потом работать с содержимым, не доставая напрямую
   Пример: Хочешь узнать, идёт ли дождь, но пока не посмотришь в окно, не узнаешь. Сам факт дождя существует, но пока ты не посмотрел в окно, для тебя его нет

3. Цикл жизни и смерти, лента рекомендаций, беговая дорожка

4. Я бы представила ООП как семью. Есть родители (классы), дети (объекты) и у всех есть какие-то привычки (методы), все они могут передавать традиции (наследование) ну и менять свое поведение со временем.
   ФП же в моих глазах это четкая инструкция, где мы трансформируем данные с помощью каких-либо функций

5. Сложно придумать что-то конкретное, мне очень нравится пример с готовкой по рецепту, поэтому пусть останется он. У нас есть входные данные в виде продуктов и мы просто выполняем шаги, не меняя исходные продукты, получаем новые

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

7. Пустой холодильник. Сколько раз не открывай, нового там ничего не появится

8. Фоновый процесс, который работает в системе и делает свою работу, не мешая пользователю и не требует с ним взаимодействия

[Alena648]

Брюханова Алена - 3/147

1. Неизменяемость – это принцип, согласно которому созданные данные или объекты не могут быть изменены, а вместо этого используется принцип версионирования, то есть вместо изменения существующих данных создаются новые с необходимыми изменениями.Пример 1: Публикация книги. Содержание уже напечатанной и опубликованной книги не может быть изменено. В дальнейшем текст можно будет корректировать, но это будет новое издание книги с изменениями.
   Пример 2: Запись голосового сообщения. Если я запишу голосовое сообщение, то уже не смогу его изменить, для этого придется записать его заново или редактировать с помощью специальных программ, но в этом случае это будет новая версия исходного голосового сообщения.
2. Монада – паттерн программирования, позволяющий задать определенную последовательность выполнения операций над данными, избегая ошибок.
   Пример 1: Рецепт приготовления пирога. Рецепт – по сути инструкция, где прописана последовательность действий, производимых над данными (в нашем случае продуктами). В рецепте есть свои этапы: приготовить тесто, залить в форму, запечь в духовке; и результат одного этапа используется в следующем.
   Пример 2: Алгоритм решения задачи по математике, например, аппроксимация функции. Нам даны исходные данные и необходимо определить, подходит ли линейная функция для описания исходных данных. Есть свои этапы решения: определение параметров уравнения регрессии, вычисление показателей (средняя ошибка аппроксимации, коэффициент детерминации), анализ полученных показателей и вывод. На каждом новом этапе мы используем данные, полученные из предыдущего этапа.
3. В качестве пример бесконечного автомата можно привести природу. В ней происходит смена времен года, дня и ночи, различные изменения в живой и неживой природе, и все это длится уже много лет.
   Вторым примером может послужить экономика: в ней так же происходит множество процессов: движение денег, производство и потребление товаров, спад и рост инвестиций и т.д.
4. Главное отличие ООП от ФП заключается в подходе к решению задач и способах организации кода. В ООП данные и их поведение объединяются в одно понятие «объект», в то время как в ФП эти понятия разделяются и главным понятием уже является «функция».
5. Задачи, для решения которых наилучшим образом подходит ФП: обработка больших объемов данных, моделирование сложных систем (движение частиц), оптимизация производительности и т.д.
6. Каррирование – преобразование функции с несколькими аргументами в функцию с одним аргументом при помощи использования вложенности функций.
7. Идемпотентность – свойство, при котором использование одного и того же действия к одним и тем же исходным данным дает один и тот же результат, например, дверной звонок: при нажатии на него всегда будет один и тот же результат – звуковой сигнал.
8. Демон в системах *nix — это программа, которая запускается самой системой и работает в фоновом режиме без прямого взаимодействия с пользователем.