В этом тесте вы сможете проверить свои знания SOLID, ответив на ряд вопросов. На каждый вопрос можно дать только один верный ответ.

Удачи!

Для чего нужен полиморфизм в программировании?

Полиморфизм в контексте ООП означает, что разные объекты могут реагировать на один и тот же запрос, проявляя разное поведение в зависимости от своего типа. Это позволяет сократить дублирование кода, улучшить читаемость и облегчить расширение программы.

Преимущества принципа полиморфизма

1. Гибкость и расширяемость. Полиморфизм позволяет добавлять новые типы объектов и операций без изменения существующего кода. Новые классы, реализующие общий интерфейс, могут быть легко интегрированы в существующую систему.
2. Упрощение кода. Полиморфизм способствует уменьшению дублирования кода. Общий интерфейс или абстрактный базовый класс позволяют описать общее поведение, и каждый конкретный класс реализует только свою специфичную логику.
3. Читаемость кода. Полиморфизм делает код более интуитивно понимаемым, так как работа с различными объектами происходит через общий интерфейс. Это упрощает восприятие кода другими разработчиками и способствует поддержке программы.
4. Расширение функциональности. Добавление новых функций или операций для существующих классов становится проще. Достаточно реализовать необходимые методы в новых классах, которые наследуют общий интерфейс.
5. Повторное использование кода. Полиморфизм позволяет использовать одни и те же методы для разных типов данных. Это устраняет необходимость создания аналогичных функций для разных классов.
6. Улучшение тестирования. Тестирование становится более удобным, так как можно создать общие тестовые сценарии для всех классов, реализующих один интерфейс. Это способствует повышению качества и надежности программы.
7. Абстракция и инкапсуляция. Полиморфизм позволяет абстрагироваться от конкретных реализаций и сосредоточиться на общем поведении объектов. Также он способствует инкапсуляции, разделяя интерфейс от деталей реализации.
8. Облегчение командной разработки. Когда разработчики работают над разными частями программы, полиморфизм позволяет им взаимодействовать через общие интерфейсы без необходимости глубокого понимания внутренней реализации друг друга.

Виды полиморфизма в объектно-ориентированном программировании

Разные виды полиморфизма в объектно-ориентированном программировании обеспечивают гибкость и расширяемость кода. Они позволяют обращаться с разными типами данных единообразно, что делает программы более понятными и удобными для разработки и обслуживания программного кода.

1. Полиморфизм подтипов (наследования)

Этот вид полиморфизма основан на наследовании и позволяет объектам дочерних классов использоваться как объекты родительского класса. Это делает код более гибким и облегчает добавление новых типов.

2. Параметрический полиморфизм (обобщённое программирование)

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

3. Полиморфизм в интерфейсах

Интерфейсный полиморфизм позволяет объектам разных классов реализовывать общий интерфейс и предоставлять схожее поведение без явного наследования.

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

Преимущества принципа наследования

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

1. Повторное использование кода. Наследование позволяет создавать иерархии классов, где общая функциональность реализуется в родительском классе, и все подклассы автоматически наследуют этот код. Это способствует повторному использованию кода, что уменьшает дублирование и облегчает его поддержку.
2. Расширяемость. Принцип наследования позволяет создавать новые классы, расширяющие функциональность существующих классов. Подклассы могут добавлять новые свойства и методы, а также переопределять поведение унаследованных методов. Это делает код более гибким и позволяет легко вносить изменения.
3. Упрощение кода. Использование наследования позволяет разбивать большие и сложные классы на более мелкие и управляемые части. Каждый подкласс специализируется на определенном аспекте функциональности, что упрощает понимание и поддержку кода.
4. Полиморфизм. Наследование поддерживает концепцию полиморфизма, которая позволяет обращаться к объектам подклассов через ссылки на родительские классы. Это облегчает обработку групп объектов с различными типами, что упрощает написание общего и универсального кода.
5. Абстракция. Наследование позволяет выделить общие характеристики объектов и создать абстрактные классы, которые определяют интерфейс для группы связанных классов. Абстрактные классы предоставляют общую сущность без необходимости определения всех деталей реализации.
6. Структурирование кода. Наследование помогает упорядочить классы в логические иерархии, что улучшает структуру программы. Каждый класс наследует функциональность от одного или нескольких родительских классов, что улучшает организацию кода и делает его более понятным и легко поддерживаемым.

В целом, принцип наследования позволяет создавать более гибкие, модульные и расширяемые программы, что упрощает разработку и сопровождение сложных проектов. Он способствует повторному использованию кода и помогает соблюдать принципы DRY (Don’t Repeat Yourself) и SOLID, что в свою очередь способствует созданию качественного и эффективного кода.

Пример наследования в ООП

Рассмотрим пример кода на Java:

В этом примере у нас есть родительский класс Animal, который содержит общие свойства и методы для всех животных. Затем есть два подкласса Dog и Cat, которые наследуют свойства и методы от класса Animal. Каждый подкласс также имеет свои собственные уникальные свойства и методы. Обратите внимание на использование ключевого слова extends при объявлении подклассов.

Принцип наследования позволяет нам использовать общие характеристики и функциональность из родительского класса и при этом иметь возможность расширять или переопределять их в подклассах для создания более специфичных типов объектов.

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

Преимущества принципа инкапсуляции

Инкапсуляция данных имеет множество практических применений в разработке программного обеспечения. Вот несколько примеров использования инкапсуляции на практике:

1. Безопасность данных. Инкапсуляция позволяет защитить данные объекта от некорректного доступа и изменения извне. Класс может предоставлять только определенные методы (геттеры и сеттеры) для доступа к данным, которые проверяют правильность операций и обеспечивают безопасность данных.
2. Сокрытие реализации. Когда класс инкапсулирует свою реализацию, то изменения внутри класса не отражаются на внешнем коде. Это позволяет менять реализацию объекта, не нарушая функциональность клиентского кода, что облегчает поддержку и эволюцию программы.
3. Упрощение интерфейса. Инкапсуляция позволяет предоставить простой и понятный интерфейс для работы с объектами. Клиентский код взаимодействует только с публичными методами класса, не требуя знания деталей его внутренней реализации.
4. Модульность. Инкапсуляция помогает создавать модульные системы, где каждый класс представляет собой отдельный модуль со своими данными и методами. Модули могут взаимодействовать друг с другом через публичные интерфейсы, что способствует повышению читаемости и понимаемости кода.
5. Принцип единственной ответственности. Инкапсуляция способствует соблюдению принципа единственной ответственности (Single Responsibility Principle). Класс, инкапсулирующий определенные данные и операции с ними, должен отвечать только за эти данные и их обработку.
6. Контроль доступа. Инкапсуляция ООП позволяет устанавливать уровни доступа к данным и методам класса. Таким образом, некоторые данные и функциональность могут быть скрыты от других классов или пакетов, что способствует защите и контролю кода.

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

Пример инкапсуляции в ООП

Рассмотрим инкапсуляцию на простом примере:

В приведенном примере класс BankAccount инкапсулирует данные о банковском счете (accountNumber и balance) и предоставляет интерфейс для работы с ними. Поля accountNumber и balance объявлены как private, что делает их доступными только внутри класса.

Для доступа к данным счета извне класса используются публичные методы (геттеры и сеттеры). В данном случае, методы getAccountNumber() и getBalance() позволяют получить номер счета и баланс соответственно. А методы deposit() и withdraw() предоставляют возможность внести или снять деньги со счета.

Таким образом, внешний код может использовать объект BankAccount, зная только публичные методы, а не внутренние детали реализации класса. Это позволяет безопасно изменять внутреннюю реализацию класса BankAccount, не затрагивая код, который с ним взаимодействует.

Читайте также о принципе абстракции в ООП.

Что такое SOLID принципы?

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

Понимание SOLID является обязательным для всех разработчиков, и в этой статье мы объясним их простым языком.

Расшифровка SOLID

Аббревиатура SOLID включает в себя название пяти принципов «хорошего дизайна», когда речь идет о разработке программного обеспечения. Акроним SOLID означает следующие принципы:

1. Принцип единственной ответственности (Single Responsibility Principle – SRP): Каждый класс должен иметь только одну причину для изменения. Это означает, что класс должен быть ответственным только за одну конкретную функцию или задачу. Этот принцип помогает сделать классы более связанными, легко понятными и поддерживаемыми.
2. Принцип открытости/закрытости (Open/Closed Principle – OCP): Программные сущности, такие как классы, модули и функции, должны быть открыты для расширения, но закрыты для модификации. Вместо изменения существующего кода, следует добавлять новый код для внесения изменений. Это позволяет создавать более стабильные и гибкие системы.
3. Принцип подстановки Лисков (Liskov Substitution Principle – LSP): Объекты в программе должны быть заменяемыми экземплярами их базовых типов, не нарушая корректность программы. Это означает, что код, который работает с базовым типом, должен работать и с любым его подтипом, не вызывая ошибок или неожиданного поведения. Этот принцип обеспечивает согласованность в использовании наследования и полиморфизма.
4. Принцип разделения интерфейса (Interface Segregation Principle – ISP): Клиенты не должны зависеть от интерфейсов, которые они не используют. Вместо создания общих интерфейсов следует создавать специфические интерфейсы, предназначенные для конкретных клиентов. Это позволяет избежать излишней связности между компонентами системы и улучшить модульность.
5. Принцип инверсии зависимостей (Dependency Inversion Principle – DIP): Классы должны зависеть от абстракций, а не от конкретных реализаций. Высокоуровневые модули не должны зависеть от низкоуровневых модулей. Оба типа модулей должны зависеть от абстракций. Этот принцип помогает уменьшить связанность между компонентами системы и повысить их переиспользуемость.

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

Акроним SOLID принципов был сформулирован Робертом С. Мартином, также известным как «Дядя Боб», одним из самых влиятельных разработчиков программного обеспечения в области разработки программного обеспечения.

Хотя многим эти принципы могут показаться сложными, мы постараемся объяснить их простым и понятным способом.

Принцип единой ответственности

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

Предположим, у нас есть файл с именем «автомобиль» с кодом, отвечающим за эксплуатацию, управление, контроль и мониторинг автомобиля. В соответствии с принципом единой ответственности каждая из этих задач должна быть разделена на отдельный файл или компонент. Также стоит отметить, что SRP применяется не только к классам, но и к функциям и методам.

SOLID примеры на Python — принцип единой ответственности

Концепция принципа единой ответственности (SRP) заключается в том, что класс должен иметь только одну причину для изменения. Давайте рассмотрим пример с классом User, который нарушает этот принцип:

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

Давайте применим принцип единой ответственности, разделив класс User на несколько отдельных классов с единой ответственностью:

Теперь каждый класс имеет только одну ответственность. Класс User отвечает только за данные пользователя и сохранение их в базе данных. Класс EmailSender занимается отправкой электронной почты, а класс ReportGenerator отвечает за генерацию отчета пользователя.

Это пример применения принципа единой ответственности, который помогает разделить функциональность на более мелкие и специализированные классы, упрощает понимание кода и делает его более гибким для изменений.

Визуальное представление SRP

Визуализация SRP, как одного из SOLID принципов, может быть представлена в виде диаграммы классов, где каждый класс имеет только одну ответственность. Каждый класс должен быть ответственным только за выполнение одной конкретной функции или задачи. Если класс имеет несколько ответственностей, это может указывать на нарушение SRP:

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

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

Резюмируя

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

Принцип открытого-закрытого

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

SOLID примеры на Python — принцип открытого-закрытого

Принцип открытого-закрытого (Open/Closed Principle – OCP) заключается в том, что программные сущности, такие как классы, модули и функции, должны быть открыты для расширения, но закрыты для модификации. Давайте рассмотрим пример с классами Shape и AreaCalculator, где будем применять принцип OCP:

В этом примере у нас есть абстрактный класс Shape, который определяет метод calculate_area(). Затем у нас есть два класса-наследника Rectangle и Circle, которые реализуют этот метод для расчета площади прямоугольника и круга соответственно.

Класс AreaCalculator отвечает за вычисление общей площади для набора фигур. Он использует SOLID принцип OCP, поскольку он открыт для расширения новыми типами фигур, но закрыт для модификации своей основной логики. Если мы хотим добавить новый тип фигуры, например, треугольник, мы можем создать новый класс Triangle, реализующий метод calculate_area(), и передать его в AreaCalculator.calculate_total_area() без изменения самого AreaCalculator:

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

Резюмируя

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

Принцип подстановки Барбары Лисков

Принцип подстановки Лисков — еще одна важная концепция. Он предполагает, что объекты подклассов должны быть полностью взаимозаменяемы с объектами своих родительских классов, т. е. любой дочерний класс должен вести себя точно так же, как родительский класс. Это также известно как «полиморфизм подтипов» и помогает разработчикам создавать более управляемый и надежный код.

SOLID примеры на Python — принцип подстановки Барбары Лисков

Принцип подстановки Барбары Лисков (Liskov Substitution Principle – LSP) гласит, что объекты должны быть заменяемыми экземплярами их базовых типов без нарушения корректности программы. Давайте рассмотрим пример с классами Rectangle (Прямоугольник) и Square (Квадрат), чтобы проиллюстрировать принцип LSP:

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

Класс Square наследуется от Rectangle и переопределяет методы set_width() и set_height(). В случае квадрата ширина и высота всегда должны быть одинаковыми, поэтому при установке одного измерения класс Square автоматически устанавливает и другое измерение равным ему.

Однако данный пример нарушает SOLID принцип LSP. Рассмотрим следующий код:

В этом примере мы вызываем функцию print_area(), которая ожидает объект типа Rectangle. Когда мы передаем rectangle, результат площади правильный (20), потому что ширина и высота были установлены независимо. Однако, когда мы передаем square, ожидаемая площадь должна быть также 20, но фактически получаем 16. Это происходит из-за изменения поведения методов set_width() и set_height() в классе Square.

Таким образом, класс Square не является полностью заменяемым объектом для класса Rectangle, нарушая принцип LSP. Чтобы исправить это, мы можем пересмотреть дизайн иерархии классов, чтобы избежать нарушения принципа LSP, или использовать интерфейсы и абстракции для достижения корректного поведения при замене объектов.

Резюмируя

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

Принцип разделения интерфейса

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

SOLID примеры на Python — принцип разделения интерфейса

Принцип разделения интерфейса (Interface Segregation Principle – ISP) гласит, что клиенты не должны зависеть от интерфейсов, которые они не используют. Вместо создания общих интерфейсов следует создавать специфические интерфейсы для конкретных клиентов. Давайте рассмотрим пример с интерфейсами для различных устройств вывода ввода:

В этом примере у нас есть абстрактные классы InputDevice и OutputDevice, представляющие интерфейсы для устройств ввода и вывода соответственно. Затем мы определяем конкретные классы Keyboard, Mouse, Monitor и Printer, которые реализуют соответствующие методы.

Применяя SOLID  принцип ISP, мы разделяем интерфейсы на более специфические, чтобы клиенты могли зависеть только от интерфейсов, которые они используют. Например, если клиенту нужен только ввод с клавиатуры, он может зависеть только от интерфейса InputDevice и использовать класс Keyboard:

В этом примере функция process_input() принимает объект, реализующий интерфейс InputDevice, и обрабатывает его ввод. Здесь мы передаем объект Keyboard, который соответствует интерфейсу InputDevice. Таким образом, клиент зависит только от необходимого интерфейса и не зависит от лишних методов или классов.

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

Резюмируя

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

Принцип инверсии зависимостей

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

SOLID примеры на Python — принцип инверсии зависимостей

Принцип инверсии зависимостей (Dependency Inversion Principle – DIP) гласит, что классы должны зависеть от абстракций, а не от конкретных реализаций. Высокоуровневые модули не должны зависеть от низкоуровневых модулей. Оба типа модулей должны зависеть от абстракций. Давайте рассмотрим пример с классами Notification и EmailSender, чтобы проиллюстрировать принцип DIP:

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

Чтобы применить SOLID принцип DIP, мы изменяем User, чтобы он зависел от абстракции Notification, а не от конкретной реализации:

Теперь User принимает объект notification_service, реализующий интерфейс Notification, через конструктор. Это позволяет передавать различные реализации уведомлений, такие как EmailSender или SMSNotification, без изменения самого User:

Теперь User зависит от абстракции Notification и может быть легко настроен для работы с различными реализациями уведомлений. Это уменьшает связанность между классами, делает их более гибкими и легкими для тестирования и модификации.

Резюмируя

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

Заключение

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

Примечание Рейтинг степени важности в разработке (0-10) является относительной оценкой и может различаться в зависимости от конкретной ситуации и контекста разработки.

Надеемся, что принципы SOLID на Python примерах оказались полезны и доступны для понимания.

Для чего нужна абстракция в программировании?

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

Преимущества абстракции в ООП

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

1. Упрощение сложности: абстракция в программировании позволяет скрыть детали реализации и сосредоточиться на ключевых аспектах системы. Это помогает упростить понимание и поддержку кода.
2. Модульность: возможность разбить систему на модули или классы, которые могут работать независимо друг от друга. Это способствует повторному использованию кода и улучшает масштабируемость проекта.
3. Повышение безопасности: абстракция позволяет скрыть некоторые детали реализации, что делает код более безопасным и защищенным. Внешние компоненты не имеют прямого доступа к внутренним деталям объекта или системы.

Пример абстракции в ООП

В качестве примера реализуем абстрактный класс «Фигура» и его наследников на языке Java:

В этом примере абстрактный класс Shape содержит общие свойства и методы для всех фигур. У него есть абстрактные методы getArea() и getPerimeter(), которые должны быть реализованы в наследниках. Классы Circle и Rectangle наследуют абстрактный класс Shape и реализуют абстрактные методы в соответствии с логикой для каждой фигуры.

В методе main() создаются объекты Circle и Rectangle, которые вызывают метод printInfo(), чтобы вывести информацию о каждой фигуре, включая цвет, площадь и периметр.

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

Также держите полезную шпаргалку по принципам ООП.

Эта статья — часть нашего полного путеводителя по Python.

1. Основы Python
2. Синтаксис Python
3. Продвинутый Python
4. Популярные библиотеки и фреймворки Python — 2023
5. Дополнительные материалы
6. Где и как изучать Python?

Основы Python

Установка Python

Для начала перейдите на официальный сайт Python и загрузите последнюю версию Python для Windows, Linux, MacOS или другой операционной системы.

Как установить Python на Windows

Выберите на сайте Python для Windows, скачайте и запустите загруженный файл. Если у вас на компьютере установлена более ранняя версия языка Python 2 — просто удалите ее и скачайте Python 3.

Выберите путь и установите программу:

Проверьте, что всё работает:

• запустите cmd;
• введите python;
• если всё хорошо, командная строка выведет версию языка.

По умолчанию будут установлены:

1. Интегрированная среда разработки IDLE.
2. Документация.
3. Менеджер пакетов pip.
4. Стандартный набор тестов.
5. Python Launcher.

Как установить Python на Linux

Для большинства сборок Linux Python идет из коробки. Проверить это можно так — откройте окно терминала и выполните команды:

• python — version;
• python2 — version;
• python3 — version.

Если по какой-либо причине на вашей системе стоит старая версия, вы можете самостоятельно скомпилировать последнюю версию Python.

Как установить Python на MacOS

Python также входит в сборку MacOS, и его можно запустить через терминал. Если же вы хотите установить самую последнюю версию — она доступна по ссылке.

Рабочее окружение

Обучение языку Python начинается с настройки рабочего окружения.

Среды разработки Python

Вот лишь несколько наиболее популярных Python IDE:

1. PyCharm — это IDE, разработанная компанией JetBrains. Она предоставляет интегрированную среду для разработки Python-приложений, включая поддержку Django, Flask и других фреймворков. PyCharm имеет богатый набор функций, включая отладчик, инструменты для анализа кода и удобный интерфейс.
2. Visual Studio Code — это легкий, быстрый и невероятно гибкий редактор кода, доступный на всех платформах. Отличный выбор для программирования на Python. Многофункциональная IDE включает в себя интегрированный отладчик, рефакторинг, автодополнение кода, etc.
3. Spyder — IDE, которая является частью научно-вычислительной среды Anaconda. Есть множество инструментов для работы с научными вычислениями, включая визуализацию данных, анализ и т. д. Spyder имеет встроенную консоль IPython, которая облегчает отладку и выполнение кода.
4. Sublime Text — легкий редактор кода, который может быть расширен с помощью плагинов и расширений для поддержки Python. Простой интерфейс, автодополнение кода и другие полезные функции.
5. Atom — этот простой на первый взгляд редактор обладает богатым функционалом. Данная среда написана разработчиками GitHub с использованием Electron — фреймворка для создания кросс-платформенных десктопных приложений средствами HTML, CSS и JavaScript.

Виртуальное окружение Python

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

ПО для работы с виртуальным окружением можно разделить на то, что входит в стандартную библиотеку Python, и то, что не входит в нее. Наиболее популярные инструменты:

• Virtualenv — один из самых популярных инструментов для создания виртуальных окружений. Прост в установке и использовании.
• Pyenv — тулза для изоляции версий Python. pyenv. Полезен, когда на одной машине нужно сразу несколько версий интерпретатора для тестирования.
• Virtualenvwrapper — обертка для virtualenv, позволяющая хранить все изолированные окружения и управлять ими.
• Venv — входит в стандартную библиотеку Python. Появился в версии Python 3 и по функционалу похож на virtualenv.

Git

Обучение языку Python с нуля включает также изучение систем контроля версий — VCS. Именно они позволяют отслеживать и фиксировать любые изменения в коде: вы можете восстановить код в случае сбоя или откатить до более ранних версий.

Git — самая популярная VCS и мастхэв-инструмент для взаимодействия нескольких разработчиков на одном проекте. Подробнее о данной VCS вы можете почитать в нашем руководстве по командной разработке с Git.

HTTP-протоколы

HTTP-протоколы в Python-разработке используются для создания веб-приложений и веб-сервисов, которые могут обмениваться данными с пользователем.

Для работы с HTTP-протоколами в Python используется стандартная библиотека urllib, которая предоставляет функции для отправки HTTP-запросов и обработки ответов.

Также для работы с HTTP-протоколами можно использовать более специализированные библиотеки, такие как requests или aiohttp:

1. Библиотека requests облегчает отправку HTTP-запросов и обработку ответов, предоставляя более высокоуровневый интерфейс для работы с протоколом. Она позволяет создавать сеансы, работать с куками, заголовками и параметрами запроса, а также обрабатывать различные типы ответов.
2. Библиотека aiohttp предоставляет асинхронный интерфейс для работы с HTTP-протоколами, что позволяет создавать более производительные и масштабируемые приложения. С ней можно использовать asyncio для создания событийных циклов, работать с потоками и обрабатывать различные типы запросов/ответов.

Знание HTTP-протоколов важно для разработчиков на Python, так как это позволяет им создавать эффективные и безопасные веб-приложения.

Базы данных

Даже начинающий Python-разработчик должен быть в курсе баз данных: а именно знать, что это такое и как с ними работать.

Одной из главных особенностей использования баз данных в Python является наличие множества библиотек, позволяющих взаимодействовать с различными типами СУБД. Вот лишь некоторые инструменты для работы с базами данных в Python:

• SQLAlchemy.
• Django ORM.
• Peewee.
• Pony ORM.

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

Например, SQLAlchemy предоставляет возможность создания SQL-запросов с помощью объектов Python, что позволяет создавать сложные запросы и обращаться к базам данных, используя ORM.

Django ORM является частью веб-фреймворка Django и предоставляет более простой интерфейс для работы с БД, не требуя написания SQL-запросов вручную.

Кроме того, Python поддерживает работу с базами данных NoSQL, такими как MongoDB и Redis, что может быть полезно для работы с большими объемами данных и их обработки в режиме реального времени. Библиотеки для работы с такими БД также существуют и могут быть найдены в PyPI.

Синтаксис Python

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

Начните практику с наших задач по Python для начинающих.

Типы данных

Python поддерживает различные типы данных, включая:

1. Числовые типы: целые числа (int), числа с плавающей точкой (float), комплексные числа (complex).
2. Строки: последовательности символов, определенных в кавычках (str).
3. Булевы значения: TRUE и FALSE (bool).
4. Списки: упорядоченные изменяемые коллекции объектов (list).
5. Кортежи: упорядоченные неизменяемые коллекции объектов (tuple).
6. Множества: неупорядоченные коллекции уникальных элементов (set).
7. Словари: неупорядоченные изменяемые коллекции пар «ключ — значение» (dict).

Одной из ключевых особенностей типов данных в Python является то, что переменные не требуют объявления типа явным образом. Тип переменной определяется автоматически во время выполнения программы. Кроме того, Python также поддерживает динамическую типизацию: это означает, что переменные могут изменять свой тип во время выполнения программы.

Операторы и приоритетность операторов

Операторы Python делятся:

1. На арифметические операторы.
2. Операторы сравнения.
3. Операторы присваивания.
4. Логические операторы.
5. Операторы принадлежности.
6. Операторы тождественности.
7. Битовые операторы.

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

Кроме того, Пайтон разработчик с нуля должен понимать, как работает приоритетность операторов. В выражении интерпретатор Python выполняет операторы с более высоким уровнем приоритета первыми. И за исключением оператора возведения в степень (**) они выполняются слева направо.

Следующая таблица демонстрирует приоритетность — самые приоритетные операции вверху, внизу — с низким приоритетом:

Переменные

Переменные предназначены для хранения данных. Название переменной в Python должно начинаться с алфавитного символа или со знака подчеркивания, может содержать алфавитно-цифровые символы и знак подчеркивания.

В Python применяется два типа наименования переменных: camelCase и underscore_notation.

Оба варианта будут верны, но учтите, что это разные переменные. Также надо учитывать регистрозависимость, поэтому переменные onlineschool и Onlineschool будут представлять разные объекты.

Закрепим, что переменные в Python объявляются без явного указания их типа, а тип переменной определяется автоматически во время выполнения программы. Плюс переменные могут изменять свой тип во время выполнения программы.

Подробнее о переменных

Отступы

Если в других языках программирования отступы в коде предназначены только для удобочитаемости, то в Python они очень важны.

Пример:

Однако в следующем случае вы получите ошибку:

Учитывайте это при написании программ.

Логические операторы

Язык программирования Python очень прост для обучения с нуля, ведь его синтаксис схож с синтаксисом других ЯП. Это касается и логических операторов:

• and — возвращает True, если оба утверждения верны;
• or — возвращает True, если хоть одно из утверждений верно;
• not — обратный результат, возвращает False, если результат верен.

Условия Python и операторы if-else

Python поддерживает обычные логические условия из математики:

1. Равно: а == b
2. Не равно: а != b
3. Меньше, чем: а < b
4. Меньше или равно: a <= b
5. Больше, чем: а > b
6. Больше или равно: a >= b

Эти условия можно использовать несколькими способами, чаще всего в операторах if и циклах.

А вот пример использования оператора if:

В этом примере две переменные, a и b, используются как часть оператора if, чтобы проверить, больше ли b, чем a. Поскольку a = 33, b = 200, мы знаем, что 200 больше 33, поэтому выводим на экран b больше чем a.

Ключевое слово elif — это способ Python сказать: «Если предыдущие условия неверны, попробуйте это условие».

В примере a равно b, поэтому первое условие неверно, но условие elif истинно, поэтому мы выводим на экран a и b равны.

Ключевое слово else улавливает всё, что не улавливается предыдущими условиями:

В этом примере a больше, чем b, поэтому первое условие неверно, также условие elif неверно, поэтому мы переходим к другому условию и выводим на экран a больше чем b.

Циклы

Любой курс Питон разработчика включает изучение циклов. Циклы позволяют выполнять некоторое действие, в зависимости от соблюдения условия. В языке Python есть следующие типы циклов:

• while;
• for.

С помощью цикла while мы можем выполнять набор операторов, пока условие истинно:

Цикл for используется для перебора последовательности (то есть списка, кортежа, словаря, набора или строки). С помощью цикла for мы можем выполнить набор операторов один раз для каждого элемента в списке, кортеже, наборе и т. д. Пример использования:

Подробнее о циклах в программировании.

Функции

Python также поддерживает функции, которые могут принимать аргументы и возвращать значения. Функции в Python могут быть определены как встроенные (built-in) или определены пользователем.

Обычно функция определяется с помощью инструкции def. Определим простейшую функцию:

Инструкция return говорит, что нужно вернуть значение. В нашем случае функция возвращает сумму x и y. Теперь мы можем ее вызвать:

Функция может принимать произвольное количество аргументов или не принимать их вовсе. Также распространены функции с произвольным числом аргументов, функции с позиционными и именованными аргументами, обязательными и необязательными.

Классы

Классы — это основа объектно-ориентированного программирования (ООП) в Python. Классы используются для определения объектов, которые могут иметь свойства (переменные) и методы (функции).

В Python классы создаются с помощью ключевого слова class. Вот пример простого класса Person с одним свойством (имя) и одним методом (приветствие):

В этом примере метод __init__ является конструктором класса и инициализирует свойство name. Метод say_hello выводит приветствие, используя значение свойства name. Чтобы создать экземпляр класса Person, нужно вызвать его конструктор с соответствующим аргументом.

Например, чтобы создать объект person с именем Алиса, мы можем написать следующий код:

Python-разработчик, написавший таким образом класс с нуля, может вызывать методы объекта person, например:

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

Методы

В Python методы — это функции, которые определены внутри класса и могут вызываться в экземплярах этого класса. Методы могут изменять состояние объекта, обращаться к его свойствам и выполнять другие операции.

Вот пример класса Rectangle, который имеет два свойства (ширина и высота) и два метода (вычисление площади и периметра):

Метод __init__ является конструктором класса и инициализирует свойства width и height. Методы area и perimeter вычисляют площадь и периметр прямоугольника, используя значения свойств width и height.

Чтобы создать экземпляр класса Rectangle, нужно вызвать его конструктор с соответствующими аргументами. Например, чтобы создать объект rect с шириной 10 и высотой 5, мы можем написать следующий код:

Теперь можно вызывать методы объекта rect, например:

Методы могут принимать аргументы, как и обычные функции. Они также могут вызывать другие методы или обращаться к другим свойствам объекта. Кроме того, Python поддерживает статические методы и методы класса, которые могут быть вызваны на классе, но не в его экземплярах.

Продвинутый Python

На этом обучение Python-разработчика не заканчивается. Необходимо понимать, как работает язык, а для этого важно углубиться в продвинутые аспекты разработки на нём.

Продвинутая тема для следующего шага — декораторы в Python.

Функциональное программирование

Функциональное программирование в Python — это подход к написанию программ, основанный на функциях высшего порядка, неизменяемости данных и отсутствии побочных эффектов.

Python поддерживает функциональное программирование, в том числе использование анонимных функций (lambda-функций), функций высшего порядка, списковых включений, генераторов, функциональных конструкций, таких как map(), reduce() и filter() и т. д.

Пример использования функции высшего порядка map(), которая применяет функцию к каждому элементу списка и возвращает новый список с результатами:

Также в Python есть поддержка генераторов, которые позволяют создавать ленивые последовательности значений. Пример использования генератора для создания бесконечной последовательности чисел Фибоначчи:

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

Лямбда-функции

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

Пример использования лямбда-функции для возведения числа в квадрат:

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

Пример использования лямбда-функции в качестве аргумента map() для возведения каждого элемента списка в квадрат:

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

Мапы, списки, коллекции

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

Коллекции — это контейнеры, которые содержат набор элементов. Они бывают двух типов: изменяемые (списки, множества, словари) и неизменяемые (кортежи, строки). Например, множество — это коллекция, которая не содержит дублей и может быть изменена:

Map — функция, которая принимает функцию и последовательность и применяет данную функцию к каждому элементу последовательности, возвращая новую последовательность с результатом. Пример:

Ошибки и их обработка в Python

В Python при выполнении программ могут возникать ошибки или исключения, такие как деление на ноль, попытка доступа к несуществующему индексу списка, неверное имя переменной и другие. Для этого в программах обучения на Питон разработчика с нуля предусматривается блок разбора исключений через конструкцию try-except.

Try-except позволяет «поймать» исключение и выполнить действия по его обработке, не прерывая выполнение программы. Конструкция выглядит следующим образом:

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

Также можно использовать конструкцию try-except для обработки нескольких типов исключений одновременно:

I/O

В Python для работы с I/O (вводом/выводом) существуют встроенные функции и модули. Например, функции print и input используются для ввода и вывода данных в консоль:

Для работы с файлами в Python есть функция open(), которая открывает файл на чтение или запись. Функция возвращает объект типа file, который позволяет производить операции с файлом:

Кроме того, в Python есть множество модулей для работы с различными форматами данных, такими как CSV, JSON, XML и другими:

Регулярные выражения

Регулярками называются шаблоны, которые используются для поиска соответствующего фрагмента текста и сопоставления символов. Подробнее о регулярных выражениях в Python.

Тестирование

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

Две наиболее популярные библиотеки для тестирования на языке Python — unittest и pytest:

1. Unittest — это стандартный модуль тестирования в Python, с которым можно писать и запускать тесты для проверки работоспособности кода и который Python-разработчик должен знать с нуля. Он содержит множество методов и атрибутов для создания тестовых сценариев, утверждений и сбора результатов тестирования.
2. Pytest — библиотека тестирования в Python, которая обеспечивает более простой и элегантный подход к написанию тестов, чем unittest. Она предоставляет широкий спектр возможностей, включая автоматическое обнаружение и запуск тестов, улучшенный вывод результатов тестирования, множественные плагины и расширения, а также поддержку различных типов тестирования.

Популярные библиотеки и фреймворки Python — 2023

Data Science

• NumPy — библиотека для работы с массивами данных, матрицами и алгоритмами линейной алгебры.
• Pandas — библиотека для обработки и анализа данных, предоставляющая удобный интерфейс для работы с таблицами данных.
• Matplotlib — для визуализации данных, создания графиков, диаграмм и других типов графических представлений данных.
• Scikit-learn — содержит реализации многих алгоритмов машинного обучения, включая классификацию, регрессию, кластеризацию и другие.
• TensorFlow — обеспечивает мощные инструменты для создания, обучения и использования нейронных сетей.

Веб-разработка

• Django — высокоуровневый фреймворк для веб-разработки, обеспечивающий удобную абстракцию для создания веб-приложений, включая аутентификацию, авторизацию, работу с базами данных и многие другие функции.
• Flask — легкий и гибкий фреймворк для веб-разработки, который позволяет создавать быстрые и масштабируемые веб-приложения.
• SQLAlchemy — библиотека для работы с базами данных, обеспечивающая удобный и гибкий интерфейс для работы с различными типами баз данных.
• Requests — библиотека для работы с HTTP-запросами, которая позволяет отправлять и получать данные с веб-серверов.
• Beautiful Soup — библиотека для парсинга HTML- и XML-документов, которая обеспечивает удобный способ извлечения данных из веб-страниц.

Геймдев

• Pygame — это библиотека для разработки 2D-игр на Python. Она содержит инструменты для управления графикой, звуком и событиями, такими как нажатия клавиш и мыши.
• Panda3D — фреймворк для разработки 3D-игр на Python. Обеспечивает разработчикам высокую степень контроля над графикой и физикой игры, а также облегчает создание сложных 3D-сцен и объектов.
• Arcade — библиотека для разработки 2D-игр на Python. Предоставляет инструменты для работы с графикой, физикой и анимацией, а также поддерживает множество вспомогательных функций, таких как загрузка изображений и звуков.
• PyOpenGL — библиотека для работы с графикой OpenGL на Python. Предоставляет высокоуровневый интерфейс для создания 3D-объектов и сцен, множество инструментов для управления освещением, материалами и текстурами.

Дополнительные материалы

Книги

Подкасты

• https://podcast.python.ru/
• https://realpython.com/podcasts/rpp/ — для тех, кто владеет английским.

Также можете посмотреть и послушать полезные подкасты от MoscowPython:

Курсы

Хотите быстро освоить весь базис, представленный в нашей дорожной карте? Это легко реализовать с онлайн-университетом Skypro, который выпускает уверенных разработчиков на Python. Специальный онлайн-курс «Python-разработчик» с трудоустройством от Skypro предполагает обучение программированию на Python с нуля до профи.

Для тех, кто не хочет учиться в большой группе, предусмотрен тариф «Премиальный». Здесь будущий Python-разработчик получит индивидуальное обучение: тариф предусматривает мини-группы по пять человек.

В программу также добавлены уроки по английскому для IT-специалистов.

Где и как изучать Python?

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

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

Но есть ли смысл оплачивать одного специалиста, если есть возможность пройти полноценные курсы Python-разработчика, где вашим развитием будут заниматься опытные наставники?

Например, у SkyPro есть курс Python-разработчика с нуля. За 10 месяцев вы освоите базу, познакомитесь с необходимыми инструментами на практике, создадите 7 пет-проектов для портфолио и сможете претендовать на позицию младшего разработчика. По окончанию курса вы получите диплом о профессиональной переподготовке, а карьерные консультанты помогут правильно составить резюме и подготовиться к вопросам рекрутеров на собеседованиях.

Мы же надеемся, что статья оказалась для вас полезной. Остались вопросы? Задайте их в комментариях.

Реклама ОАНО ДПО «СКАЕНГ» LjN8JvxFj

Налейте любимый напиток в огромную кружку и украсьте этот день мемами, потому что It Is Wednesday My Dudes!

Сисадминов выбираем мы сами, но лучших оставляет время ☝️☝️☝️

Ауф!

Ауф:

20 лет опыта против 8 выходных дней

Когда вернулся к работе после новогодних:

Не забывайте отдыхать:

«Иди на Stack Overflow дальше, это твоё распределение, это твой путь и твой горизонт познания»

Когда познал всю кодовую базу:

Вспомнить всё. Или дать функции понятное название

Когда возвращаешься к коду спустя месяц и пытаешься вспомнить что каждая функция делает:

Называя функции понятно, вы помогаете не только коллегам, но и самому себе в будущем:

О важности work-life balance

А техлид не спит, потому что он работает 20 часов в сутки:

Высыпайтесь как следует, иначе…

Сам себе сисадмин

Сам не дашь — никто не даст:

Ещё одна битва в бесконечной войне:

Windows vs Linux. Снова

Потому что винда с тобой нянчится, а Linux обращается как с равным:

Слишком плохо, чтобы быть неправдой:

Карьерный рост

Нужно как-то ещё проскочить позиции мидла и джуна:

В любом случае, всё проконтролирует продакт:

Программирование от чайников

Разница между Java и JavaScript такая же как и между «панк» и «панкреатит»:

Здесь же Java и JS встретились в реальной жизни:

Код всё ещё торт

Синтаксический сахар:

Покрутить не помогает:

Видели мемы прикольнее? Делитесь в комментариях! ?

На первый взгляд, стать самым быстрым программистом — отличная цель. Кто успевает сделать больше фич, тот и приносит компании больше денег, да? А кто приносит больше денег, тому и самую большую зарплату, правильно?

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

Ну хорошо, а как замерить скорость программиста или команды?

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

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

Кейс HP LaserJet

В 2008 году компания Hewlett Packard обнаружила себя в трудной ситуации. Исследование показало, что на разработку нового функционала HP LaserJet у компании оставалось лишь 5% всего времени — все остальное съедали сложности, возникающие при разработке кода под множество устройств.

Это заставило компанию запустить большую перестройку процессов. Новые процессы базировались на идеях экстремального программирования.

Ключевые нововведения:

• Практически полностью автоматизированное тестирование;
• четыре уровня проверки кандидата к релизу — от самых быстрых тестов с частотой до 12 прогонов в день до самых медленных с частотой до 1 раза в сутки;
• автоматизация инфраструктуры и развертываний. Любые изменения вплоть до конфигураций проходили через систему контроля версий и тесты, откуда автоматически развертывались на стенды;
• короткие циклы планирования вместо разработки больших проектов на много месяцев вперед;
• и самое радикальное — разработка на одной ветке, или, как сейчас говорят, trunk based development. Каждый день в главную ветку вливались по 10-14 коммитов, что позволило предотвратить все варианты интеграционных конфликтов.

В результате удалось добиться сокращения затрат на большинство активностей в разы. Это позволило высвободить время для инноваций: процент времени, затрачиваемого на новый функционал, увеличился с 5% до 40%.

Самое интересное тут то, что времени на тестирование не стало меньше, оно даже, наоборот, удвоилось: несмотря на то, что ручное тестирование сократилось в три раза, теперь 23% всего времени уходило на автоматические тесты. То есть, увеличив время на автоматическое тестирование и автоматизацию инфраструктуры, компания смогла тратить меньше на остальные активности. Таким образом скорость разработки выросла на невероятные 700%.

Сильные и слабые команды

Это не столько частный случай, сколько общая практика. В 2016 году организация DORA в ежегодном исследовании State of Devops опубликовала свои замеры.

Оказалось, что сильные команды тратили на переделывание и незапланированную работу на 22% меньше, а на новую работу на 29% времени больше, чем слабые. Через год разрыв увеличился: сильные команды стали тратить на переделывание и незапланированную работу на 26% меньше и на 44% больше на новую работу. Таким образом, сильные команды в среднем тратят почти в полтора раза больше времени на полезную работу.

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

Зачем нужна автоматизация

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

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

Ну хорошо, а кто должен писать все эти тесты?

Здесь все то же исследование State Of Devops демонстрирует еще более удивительную связь: тесты, написанные тестировщиками или даже отдельными командами, как оказалось, ничем не помогают. Только тесты, написанные самими разработчиками, позволяют добиться повышения эффективности команды.

Почему так?

Тут, на самом деле, нет единого ответа. Статистика указывает на корреляцию, но не объясняет, в чем дело. Может быть, когда разработчики пишут тесты сами, не происходит классического расщепления ответственности за качество кода между кодерами и тестерами. Может быть, дело в том, что к таким тестам у самих программистов гораздо больше доверия. А возможно, здесь важна именно комбинация множества факторов.

Суть остается неизменной: разработчики, одержимые тестами, добиваются значительно лучших результатов, чем их более консервативные коллеги.

Ладно, автоматизация важна. Как и что автоматизировать?

Это крайне обширная тема, которая максимально подробно освещена в книге «Непрерывное развертывание программного обеспечения» (Continuous Delivery) авторства Дейва Фарли и Джеза Хамбла.

Давайте попробуем вкратце описать процесс разработки в условиях полной автоматизации тестирования, развертывания и инфраструктуры.

Центральным элементом такого процесса является паттерн «Конвейер развертывания» (Deployment pipeline). Согласно этому шаблону, каждый коммит, попавший в главную ветку в системе контроля версий, запускает старт этого конвейера.

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

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

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

За этим следует шаг с развертыванием приложения на тестовый стенд и конфигурацией стенда. Здесь происходят все накаты миграций баз данных и все изменения настроек приложений.

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

Ни в коем случае нельзя настраивать вашу инфраструктуру вручную. Это приводит к антипаттерну «Сервер-снежинка» (Snowflake Server), когда ваш сервер уникален и неповторим, подобно снежинке. Нет ни малейшей гарантии, что то, что работает на вашей снежинке, будет работать хоть где-то еще.

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

Лучшая практика тут — приложить все усилия, чтобы этот шаг длился не более часа, чтобы у команды была возможность прогнать за день несколько попыток в случае какого-то падения. Другая популярная практика — катать приемочные тесты по ночам — приводит к тому, что команда может проверить лишь одну гипотезу в день. Это нередко выливается в то, что конвейер краснеет на несколько недель, парализуя работу всей команды.

Другой совет — ни в коем случае не пишите функциональные тесты через UI. Функционал и UI меняются по разным причинам: функционал меняется из соображений бизнеса, UI — из соображений эстетики и эргономики. Приемочные тесты, написанные через UI, приведут к тому, что любое изменение графического интерфейса будет требовать переписывания огромного массива функциональных тестов и, как следствие, ваш UI навеки замрет в том состоянии, в котором вы его однажды зафиксировали своими тестами.

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

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

И еще раз: все эти тесты, изменения инфраструктуры стенда, миграции, изменения самого конвейера заезжают в репозиторий вместе с функционалом, к которому они относятся. Необязательно в одном коммите, но обязательно должно выполняться условие — зеленые тесты означают, что система готова к релизу с точки зрения бизнеса, а зелеными они должны быть всегда. Лакмусовая бумажка: вы должны быть способны откатиться на коммит годичной давности с последующим развертыванием его через конвейер в продакшн.

Главный результат такой автоматизации: код непрерывно находится в готовом к развертыванию в продакшн состоянии, каждый новый коммит — новый релиз.

У кого-то вышеописанные процессы могут вызвать лишь ухмылку. Мол, в идеальном мире розовых единорогов такое бы, может быть, и было возможно. Отнюдь. Именно такого преобразования и удалось добиться компании HP Laser Jet и многим другим известным крупным компаниям. Но соглашусь, это высший пилотаж, требующий высокой грамотности разработчиков в области тестирования и автоматизации инфраструктуры. Впрочем, в этом и цель моего повествования: указать на ориентиры в профессиональном развитии специалиста.

Ну хорошо, автоматизация рулит, договорились. Есть ли какие-то другие способы ускорить команду?

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

Эта идея называется гипотезой выносливости дизайна, и вот уже больше полувека наша отрасль страдает от этой напасти — от проклятия кодовых баз, которые невозможно изменить из-за накопленной сложности. Бессменными спутниками таких систем становятся крайне запутанная структура кода и, самое страшное, опасные и дорогие баги, которые очень сложно исправлять.

Как с этим бороться? Есть три способа:

1. Приоритизировать простоту (правило: пишем самое простое, что может работать).
2. Рефакторинг. Всегда оставляйте код в лучшем состоянии, чем вы его застали. Наряду с первой практикой это позволит вам не только не вносить новую сложность в систему, но и постоянно ее сокращать.
3. Постепенно заменяйте ручные операции (тестирование и развертывание) автоматизированными.

Но самое дорогое в разработке программного обеспечения — работать не туда

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

Разработчики, посмотрев на это безобразие, выдали грубую оценку всей работы в 9 месяцев. Это был тоннель, в который команда бы въехала с одного конца и только через 9 месяцев, выехав с другого конца, узнала бы, был ли это успех или провал. Факт того, что команда могла выпускать новые релизы каждые пару недель, позволял не ждать 9 месяцев, чтобы проверить идею. Поэтому команда вернулась к заказчику с вопросом, как это решение может изменить чье-то поведение. Этот вопрос застал владельца врасплох:

—Что значит «изменить чье-то поведение»?—Если через 9месяцев, когда фича будет готова, все будут делать тоже, что исейчас, как будто ничего непроизошло, это будет провал?—Конечно, провал!—Тоесть кто-то должен что-то делать иначе?—Мыхотим, чтобы пользователи публиковали свои достижения в«Фейсбуке».—Уже лучше. Зачем?—Всмысле— зачем? Чтобы ихдрузья увидели эти посты.—Тоесть насамом деле мыхотим изменить поведение людей, которые неиграют вигру. Нухорошо, апочему это важно?—Если другие люди прочитают эти посты, то, возможно, они придут попробовать эту игру.—Хорошо, это еще одно изменение поведения, но все еще недает общей картины. Почему это важно?

Владелец был потрясен:

—Это глупый вопрос. Чем больше игроков, тем больше денег.—Хорошо, тоесть мыхотим больше игроков?—Конечно!—Насколько больше?—Чем больше, тем лучше.—Если спустя 9месяцев эта фича приведет 5 новых игроков, это будет успех?—Нет, конечно, мырассчитываем намиллион игроков.

Бинго! Эта цифра все время была в голове у владельца, но до разработки дошла лишь после этого разговора. В итоге первое, что требовалось сделать, — проверить, насколько идея жизнеспособна. За пару часов работы была реализована возможность опубликовать сообщение о победе в игровом турнире, однако оказалось, что за 3 дня никто так и не нажал кнопку «поделиться» — никто не хотел спамить своим друзьям сообщениями о какой-то игре в «Фейсбуке». Таким образом, это направление оказалось заблокировано.

Поступило другое предложение: теперь игрокам предоставили возможность приглашать друзей — и, о чудо, игроки начали приглашать друзей. Проблема лишь в том, что никто так и не пришел по ссылке. Отдел маркетинга предположил, что это из-за того, что в письме была плохо видна ссылка на игру. Вместо маленькой ссылки в тексте сделали большую кнопку «присоединиться» — и тут игроки пошли. Спустя две недели полировки механизма приглашений и введения разных бонусов реферальной программы у игры был миллион игроков.

Эта история позволяет сформулировать очень интересные выводы::

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

Согласно исследованию компании Microsoft, 2/3 всего разработанного функционала в лучшем случае не принесло никакой пользы. Это означает, что можно иметь крутейшую архитектуру, в которой нет ни строчки лишнего кода и избыточной сложности, можно иметь невероятные процессы, в которых каждый коммит после прогона всех видов автотестов тут же деплоится в прод — но если вы работаете не туда, то 2/3 вашей работы в лучшем случае не принесут никакой пользы. И, как правило, такие фичи лежат в кодовой базе и мешаются под ногами, съедают время в прогонах тестов, техподдержке приходится поддерживать эти фичи до самого конца продукта — а ведь ими никто и не пользуется.

Получается, что компании выгоднее было бы, если бы вы эти 2/3 времени провели на пляже, ну или на горнолыжном курорте, или просто с родными…

Вывод

Подведем итоги:

• Автоматизация тестирования и инфраструктуры приводит к росту продуктивности в среднем в полтора раза. В отдельных случаях удавалось зафиксировать рост в 8 раз.
• Центральным элементом такой автоматизации является шаблон «Конвейер развертывания». Главный результат: код непрерывно находится в готовом к развертыванию в продакшн состоянии, каждый новый коммит — новый релиз.
• Другой проблемой становится трясина легаси-кода. Главные сдерживающие факторы — запутанная структура и дорогие баги. Главные лекарства — простой дизайн, рефакторинг и автотесты.
• Самое дорогое препятствие к решению проблем бизнеса — неверно выбранный вектор работы. Очень важно, чтобы все участники процесса хорошо понимали цель, правильно выбирали метрики и работали в коротких циклах, позволяющих ошибаться быстро и дешево.

На этом у меня все. Спасибо за внимание, пишите хороший код, тесты и до новых встреч.

Общее описание логических операторов

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

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

Логические операторы

Оператор НЕ (!, not)

Выражение вида !true равно false и наоборот. Оператор ! (не) инвертирует логическое значение, это унарный оператор (применяется к одному операнду), он помещается перед операндом. Если условие истинно, то результат применения оператора отрицания будет ложным, и наоборот. Например, если a = true, то выражение !a даст false.

Например:

Оператор И (&&, and)

Оператор && — это оператор логического умножения. Выражение вида a && b будет равно true только тогда, когда и а и b равны true. Если хотя бы один из операндов окажется ложным, результат будет false. Данный оператор используется, когда необходимо, чтобы выполнялись несколько условий одновременно.

Оператор ИЛИ (||, or)

Оператор || — это оператор логического сложения. Выражение a || b будет равно true, когда или a, или b (или оба) равен true. Это полезно, когда нужно проверить, выполняется ли хотя бы одно из нескольких условий.

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

Оператор исключающее ИЛИ (^, xor)

Выражение a ^ b будет равно true, когда только один из операндов имеет значение true. Подробно о применении xor рассказывается в статье «Практика применения XOR в программировании»

Операторы сравнения

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

1. Оператор эквивалентности (==) — проверяет и сравнивает два значения. Выражение a == b будет равно true, когда a и b имеют одинаковые значения. Например, выражение 5 == 5 вернёт true, так как оба значения одинаковы.
2. Оператор неравенства (!=) — проверяет, разные ли два значения. Выражение a != b будет равно true, когда a и b имеют разные значения. Пример: 5 != 3 вернёт true, так как числа не равны.

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

Приоритет логических операторов

1. Оператор эквивалентности — ==, оператор неравенства — !=.
2. Оператор отрицания — !.
3. Оператор И — &&.
4. Оператор исключающее ИЛИ — ^.
5. Оператор ИЛИ — ||.

Предлагаем вам пройти тест и узнать, насколько хорошо вы разобрались с логическими операторами:

Что такое реактивное программирование?

Классический подход к программированию предполагает выполнение запроса (к базе, сервисам и т.д.), ожидание ответа и продолжение работы. Во время ожидания поток простаивает. Масштабируют такие системы путём увеличения количества потоков, при этом вычисление оптимального количества потоков становится непростой задачей, так как сильно зависит от характера нагрузки, количества и качества ожиданий. И несмотря на это, избежать на 100% простоя ресурсов не удается.

В реактивном программировании обработка делится на большое количество небольших задач, выполнение каждой из которых оканчивается неким событием. На возникновение этого события реагирует соответствующий обработчик и выполняет свою задачу, опять генерирует событие и общий процесс обработки продолжается. Генерация события и реакция на него происходят асинхронно. Обработчик (их ещё называют акторами) выбирает следующее событие из очереди, обрабатывает и складывает событие в очередь другому обработчику. Если задача заключается в выполнении запроса в базе данных, то актор посылает запрос на сервер. После получения ответа будет сгенерировано событие с результатом запроса и запущен соответствующий актор.

Всё это позволяет более эффективно занять ресурсы полезной работой и управлять масштабированием. Повышается отзывчивость приложений. Кроме того, реактивное программирование помогает масштабироваться горизонтально.

Понятие реактивного программирования тесно связано с понятием модели распространения данных, которая бывает двух типов:

1. pull-модель.
2. push-модель.

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

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

Его коллеге — Пете — тоже интересен хоккей, но в отличие от Васи, Петя подписался на рассылку новостей и получает уведомления о важных событиях в хоккее.

С точки зрения программирования, Вася использует pull-модель: периодически просматривает источники данных, в то время как Петя — push-модель: занимается обработкой входящих сообщений.

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

На практике этот стиль применяется для обработки входящего потока данных, например:

• сообщения от пользователей;
• уведомления об изменении расписания;
• действия пользователя с интерфейсом и т.д

Реактивное программирование — это подход к разработке ПО, который строится на реагировании на события и на распространении событий. При этом модель реакции на события предполагает возможность простого распространения этих или трансформированных событий далее по системе. Ярким примером реализации реактивного подхода может служить таблица Excel. В ней существует цепочка вычислений, разделённая на несколько ячеек: при изменении значения одной из ячеек в цепочке значения в зависимых ячейках пересчитываются автоматически.

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

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

Суть реактивного программирования можно изобразить разными способами. Например, представим реку, течение которой несет несколько разноцветных объектов (мячей). Допустим, на берегу сидит человек, которому нужно выловить объекты с определенной характеристикой – только зеленые или красные. Если нам требуется запрограммировать подобную ситуацию, то реактивный подход – это то, что поможет нам оперировать потоками данных, получать данные, совершать математические вычисления и т.д. Работа с потоками требует от программиста определенного опыта и понимания, что и как комбинировать, какие операторы подходят для решения задачи.

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

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

Реальным применением этой парадигмы может стать веб-фреймворк, поддерживающий архитектуру MVC (Model-View-Controller), в котором при изменении модели изменяется поведение пользовательских представлений.

Предположим, есть модель Пользователь с полями Имя и Фамилия. Добавляем поле Отчество — и во всех местах, будь это форма на сайте или структура базы данных, происходят соответствующие изменения: форма при следующей генерации содержит новое поле, а для БД генерируется миграция.

В рамках парадигмы чаще всего используют функции обратного вызова (callback) и конструкции асинхронного программирования (конкретные виды зависят от языка). Также здесь задействуют события (events) или потоки (flows). Если в коде есть такие «следы», значит, с большой вероятностью здесь применяется концепция реактивного программирования

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

В реактивном программировании обработка делится на большое количество небольших задач, выполнение каждой из которых оканчивается неким событием. На событие реагирует обработчик, который выполняет свою задачу и снова генерирует событие. Генерация события и реакция на него происходят асинхронно.Идея реактивного программирования призвана упростить создание и масштабирование сложных систем.Примером реактивного подхода может служить таблица Excel. В ней существует цепочка вычислений, разделённая на несколько ячеек: при изменении значения одной из ячеек значения в зависимых ячейках пересчитываются автоматически.

Напоминаем, что вы можете задать свой вопрос экспертам, а мы соберём на него ответы, если он окажется интересным. Вопросы, которые уже задавались, можно найти в списке выпусков рубрики. Если вы хотите присоединиться к числу экспертов и прислать ответ от вашей компании или лично от вас, то пишите на experts@tproger.ru, мы расскажем, как это сделать.

Что такое императивное и декларативное программирование?

Императивные языки, такие, как Java, Python, JavaScript, C, C++ занимают доминирующее положение в индустрии ПО, соответственно императивное программирование — самое распространённое. Смысл его в том, что императивная программа содержит прямые указания, что должен сделать компьютер и в каком порядке должны выполняться инструкции. Этот подход легко понять программисту, а компилятору — легко породить достаточно эффективный код.

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

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

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

Самый популярный язык РСУБД SQL так же является декларативным. На нём описывается конечный результат, а способ его получения генерируется сервером СУБД исходя из множества факторов.

Декларативное программирование может являться более сложным в понимании, но позволяет писать более безопасный и поддерживаемый код, который легко параллелится. А компиляторы декларативных языков имеют больше возможностей при оптимизации программ.

Конечно, практически все основные языки сочетают в себе элементы и декларативного и императивного программирования. Огромное влияние оказывает функциональное программирование на JavaScript, Java, C++, C# и т.д.

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

Императивное программирование — это парадигма программирования, в которой задаётся последовательность действий, необходимых для получения результата. В нём используются переменные, операторы присваивания и составные выражения.

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

Сейчас широко распространены как узкоспециализированные декларативные языки программирования (HTML + CSS, SVG, VRML, SQL, lex/VACC), в том числе функциональные (Haskell, Erlang, Scala), так и императивные языки (C/C++/C#, Java, Go, Rust, Python). Однако практически все современные языки программирования общего назначения высокого уровня, за исключением некоторых функциональных, относятся к императивным языкам.

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

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

Императивное программирование — это парадигма, основанная на составлении алгоритма действий (инструкций/команд), которые изменяют состояние (информацию/данные/память) программы. Первыми языками программирования, основанными на таком подходе, были машинные коды и ассемблеры. Фактически, программа на этих языках — это код, который выполняется компьютером сразу, без предварительной компиляции. Из языков высокого уровня, требующих компиляции исходного кода программы в машинный код (или интерпретации), к императивным можно отнести C, C++, Java.

Декларативное программирование — это парадигма, при которой описывается желаемый результат, без составления детального алгоритма его получения. В пример можно привести HTML и SQL. При создании HTML мы с помощью тегов описываем, какую хотим получить страничку в браузере, а не то, как нарисовать на экране заголовок статьи, оглавление и текст. В SQL, если нам нужно посчитать количество сотрудников с фамилией «Сидоров», мы напишем SELECT count(*) FROM employee WHERE last_name = 'Сидоров';. Тут ничего не сказано про то, в каком файле или области памяти находятся данные по сотрудникам, как именно выбрать из них всех Сидоровых и нужно ли вообще это делать для подсчёта их количества.

Рассмотрим ещё один пример. Допустим, мы хотим приготовить обед.

В императивной парадигме это выглядит как-то так:

• купить мясо, огурцы, помидоры, соль;
• порезать мясо, посолить;
• поставить сковородку на плиту;
• …

В декларативной: хочу на обед жареное мясо с овощами (неплохо звучит, правда? :)).

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

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

Что из себя представляют императивное и декларативное программирование?

Если кратко, то императивная программа содержит прямые указания, что должен сделать компьютер и в каком порядке должны выполняться инструкции. Примерами императивных языков являются Java, Python, JavaScript, C, C++.Декларативная же программа состоит из ограничений и правил, из которых компьютер генерирует способ получения результата. Пример декларативного языка: SQL.

Напоминаем, что вы можете задать свой вопрос экспертам, а мы соберём на него ответы, если он окажется интересным. Вопросы, которые уже задавались, можно найти в списке выпусков рубрики. Если вы хотите присоединиться к числу экспертов и прислать ответ от вашей компании или лично от вас, то пишите на experts@tproger.ru, мы расскажем, как это сделать.

Что такое динамическое программирование?

Динамическое программирование — достаточно широко используемый подход к решению задач, основанный на идее «разделяй и властвуй». Достаточно часто невозможно или крайне затруднительно создать некий общий алгоритм решения проблемы, который бы брал входные данные, что-то с ними делал и сразу выдавал ответ.

Часто способа решить задачу методом «делай раз, делай два, делай три» не существует. Но всегда можно разделить большую задачу на множество маленьких и дробить так до тех пор, пока упрощённые задачи не станут примитивно простыми. Это подход, известный как «разделяй и властвуй». Довольно часто для этого используется рекурсия — вызов функцией самой себя.

Важная особенность чтобы этот процесс не зациклился нужно чтобы на каком-то этапе задача сводилась к примитивному случаю, ответ на который известен сразу. Пример — вычисление факториала числа. Такую задачу можно решить и с помощью простого алгоритма n!=1·2·3·…·n, в этом случае можно сразу получить значение (например 4! = 1·2·3·4 = 24, а 5! = 1·2·3·4·5 = 120). Но эту же задачу можно решить и рекурсивно, ведь 5! = 5·4!, а 4! = 4·3! и так далее. Значит можно написать простую функцию расчета факториала n!, которая будет умножать число на результат вызова самой себя для более простого случая (n-1)!. И только в примитивном случае 1! функция вызывать саму себя не будет, а сразу вернёт 1, это важный момент, чтобы не возникло зацикливания.

Но «разделяй и властвуй» — это ещё не совсем динамическое программирование, так как такой подход хоть и прост, но часто приводит к лавинообразному росту необходимых вычислений, хоть сам метод может быть сколь угодно простым.

Взять, к примеру, задачу поиска кратчайшего маршрута по городу из точки А в точку Б. На практике такие задачи решаются с использованием теории графов, когда каждой улице в городе ставится в соответствие ребро графа, а каждой возможной точке пребывания — узел графа. Каждому ребру приписывается некоторая условная «стоимость», соответствующая, например времени прохождения или даже непосредственно денежная стоимости проезда по соответствующей «улице». Эта стоимость в реальности может даже меняться с течением времени, например из-за пробок. Тогда необходима функция, находящая кратчайший маршрут — такую последовательность узлов, пройдя через которые мы получим минимальную «стоимость» прохождения всех соединяющих их рёбер.

И вот для таких задач методы динамического программирования становится практически единственными рабочими вариантами решения. Методы рекурсии здесь уже не подойдут: можно, конечно, решить эту задачу и таким образом: написать функцию, возвращающую стоимость ухода из точки А по каждой из возможных «улиц», каждая из этих функций в свою очередь добавит к ней стоимость участка до следующего «перекрёстка», вызвав саму себя еще раз, и повторит это многократно, пока в результате не «дойдёт» до точки Б. По итогу, среди всех цепочек ответов можно будет выбрать ту, стоимость которой минимальна и получить ответ на задачу. Но на практике сделать такое возможно только для очень простых графов с десятками узлов, например для карты метро. А вот уже в масштабах карты улиц города подобные алгоритмы становятся нереалистичными.

Если вкратце, то динамическое программирование — это способ решить задачу, разбив её на мелкие задачи и скомбинировав их решения.

Обычно динамическое программирование применяют в задачах, связанных с оптимизацией, например, когда нужно найти кратчайший маршрут для перемещения из города A в город B. Либо это могут быть задачи, где нужно просчитать все возможные комбинации переходов или расположения элементов. Классический пример, в котором используется этот метод — последовательность чисел Фибоначчи.

F(n) = F(n-1) + F(n-2);
F(0)=0;
F(1)=F(2)=1;

Как видно, для решения задачек с последовательностями, нужно определить следующие условия: рекуррентная зависимость элементов последовательности друг от друга, начальное состояние. Они не всегда могут быть заданы в условии напрямую, как это было в задаче выше. Например, в видео «Динамическое программирование: траектории кузнечика» разбирают задание с количеством переходов из точки A в B.

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

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

Поиск оптимального состояния динамики, переходов и порядка пересчёта (прямой или обратный) и включает в себя метод динамического программирования.

Узнать подробности о применениях этого метода и способах его оптимизации можно почти во всех в книжках по алгоритмам, например, в книге «Алгоритмы. Построение и анализ».

В теории вычислительных систем под термином «динамическое программирование» понимается способ решения сложных задач путём разбиения их на более простые подзадачи. Динамическое программирование применимо не ко всем задачам, а лишь к тем, которые обладают «оптимальной структурой». Оптимальная структура означает, что задача может быть разбита на несколько аналогичных задач меньшего размера, при этом для решения конечной задачи могут быть использованы результаты решения меньших задач. Примеры задач с оптимальной структурой — вычисление факториала числа, построение ряда чисел Фибоначчи, вычисление расстояния Левенштейна (красивое название, скрывающееся внутри всем известной задачи diff, вычисляющей разницу между двумя текстовыми файлами). Программист, не знакомый с теорией вычислительных систем, может подумать, здесь кроется какая-то сложная математика, но на самом деле речь идёт о всем хорошо знакомом подходе — рекурсии. Все знают, как вычислить факториал числа: нужно умножить это число на факториал числа, меньшего на единицу: F(n) = n*F(n-1) (для краткости опущена проверка n >= 1) — просто и изящно.

Так вот, динамическое программирование — это рекурсия с сохранением результатов вычислений. Представим, что нам постоянно нужно вычислять факториал разных чисел. Каждый раз, когда нам нужно вычислить факториал, например, числа 5, нам необходимо произвести 4 умножения — 5*4*3*2*1. А что, если сохранить промежуточные результаты? Допустим, мы когда-то раньше вычислили 4! = 24. Значит, нам нужно проделать только одно умножение — 5*24. А в следующий раз, когда нас спросят 5!, мы вообще можем вернуть результат сразу же. Понятно, что при таком подходе растёт скорость вычислений, но и возрастает потребление памяти. Что важнее — скорость или память — вечный вопрос. Принимать решение нужно исходя из конкретных условий.

Динамическое программирование – это метод, который позволяет эффективно решать многие задачи, прежде всего, задачи комбинаторной оптимизации.

Суть метода в следующем: имеющуюся задачу рекурсивно разбиваем на более маленькие подзадачи, их — на ещё меньшие и так далее. Но решаем задачи в обратном порядке: сначала маленькие (запоминаем их решение), потом переходим к задачам побольше (строим их решение на основе сохранённых решений маленьких задач) и так далее, пока не решим исходную большую задачу.

Преимущества метода:

• за счёт запоминания решения промежуточных подзадач мы каждую такую подзадачу решаем только один раз, т.е. экономим время;
• избавляемся от рекурсии (заменяем её на вложенные циклы).

Недостаток: обычно требуется много памяти для хранения промежуточных результатов.

Вычислительная сложность многих задач не зависит от входных параметров, например, получение элемента по индексу в массиве не зависит от длины массива и всегда выполняется за константное время. В то же время есть задачи, для которых время выполнения линейно зависит от значения параметров, например, получение элемента по индексу в связанном списке ― чем больше элементов, тем больше времени потребуется на поиск нужного элемента. Естественно, существуют и задачи, для которых использование полного перебора требует слишком много времени, например, поиск кратчайшего маршрута между двумя городами в случае полного перебора потребует построение n! вариантов, что при больших n неэффективно.

Некоторые подобные задачи можно решить путем разбиения исходной задачи на подзадачи меньшего размера и сложности, решив которые и объединив результаты, можно получить решение исходной задачи. Такой подход называется динамическим программированием и был предложен Ричардом Беллманом в 1940-х годах.

Динамическое программирование придерживается двух подходов к решению задач:

• Нисходящее динамическое программирование, когда исходная задача разбивается на подзадачи. После решения подзадач результаты объединяются для получения решения исходной задачи.
• Восходящее динамическое программирование, когда сначала происходит решение подзадач, а затем объединение их результатов для решения общей задачи.

Одной из самых известных задач динамического программирования является задача вычисления чисел Фибоначчи, и она эффективно решается методом восходящего динамического программирования. При использовании этого подхода для нахождения N-го элемента в последовательности происходит последовательное нахождение первого, второго и последующих элементов как суммы двух предыдущих. Данный подход имеет сложность O(N), в то время как использование классического рекурсивного подхода имеет приблизительную сложность O(2^N), что существенно больше.

С помощью чисел Фибоначчи описываются многие явления, однако, давайте посмотрим на более практический пример ― задачу коммивояжера или, на современный лад, курьера ― курьер должен посетить N адресов, побывав на каждом из адресов ровно по одному разу и завершить свой маршрут в исходной точке. Задача заключается в нахождении маршрута минимальной длинны.

Данную задачу можно решить методом полного перебора ― сгенерировать все возможные маршруты (всего их N!) для N адресов, а затем выбрать маршрут минимальной длины. Сложность данного алгоритма O(N! * N) и время вычисления очень быстро растет при росте количества адресов ― если для трех адресов нужно рассмотреть шесть вариантов, то для 10 уже около четырех миллионов!

Использование подходов динамического программирования может не дать наилучшего решения, но, тем не менее, оно будет достаточно хорошим и за приемлемое время. Суть подхода к решению данной задачи заключается в поиске ближайшего адреса на каждом шаге ― из исходной точки, затем следующего ближайшего пункта назначения из первого адреса и так далее. Полученное решение не будет идеальным, но потребует гораздо меньше времени ― O(N^2 * 2^N), что для тех же 10 адресов 1124 вычислений.

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

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

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

Яркий пример того, как работает динамического программирование — задача нахождения N-го члена рекуррентной последовательности. В такой последовательности каждый следующий член зависит от одного или нескольких предыдущих. При этом, полностью раскрывая последовательность, мы «снижаем индекс», пока не дойдем до тривиального случая, либо до случая, на который уже есть сохраненный ответ — от него мы возвращаемся обратно и производим подсчет, сохраняя вычисленный результат для дальнейшего переиспользования. Если необходимо подсчитать большое количество членов последовательности, мы получим качественный скачок по производительности.

Данный метод применяют, чтобы ускорить и упростить решение задачи.

Что такое динамическое программирование?

Если кратко, то динамическое программирование — это способ решения сложных задач путём их разбиения на более мелкие составляющие и комбинирования их решений. Классический пример, в котором используется этот метод — последовательность чисел Фибоначчи, где каждое последующее число вычисляется из двух предыдущих.Динамическое программирование применимо не ко всем задачам, а только к тем, которые позволяют себя разбить на несколько задач поменьше и использовать их решения.

Напоминаем, что вы можете задать свой вопрос экспертам, а мы соберём на него ответы, если он окажется интересным. Вопросы, которые уже задавались, можно найти в списке выпусков рубрики. Если вы хотите присоединиться к числу экспертов и прислать ответ от вашей компании или лично от вас, то пишите на experts@tproger.ru, мы расскажем, как это сделать.

Качественный дизайн ПО — введение

В процессе работы над кодом программисты регулярно сталкиваются с тем, что качественный дизайн кода окупается впоследствии при усложнении продукта. Для создания полезного и легко поддерживаемого в долгосрочной перспективе ПО разработчики подбирают определённые шаблоны и объединяют их в абстракции, и похоже, что разработчики Linux и FFmpeg поступили именно так.

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

Предположим, что мы разрабатываем фреймворк для обработки видео- и аудиофайлов. Кодеки AV1, H264, HEVC и AAC производят некоторые идентичные операции с данными, и если мы разработаем некоторую обобщённую абстракцию, включающую эти операции, мы сможем использовать эту абстракцию вместо того, чтобы реализовывать конкретную идею, заложенную в каждом отдельном кодеке.

Ещё один хороший приём — использовать слабо связанные компоненты, чётко определив их функции.

Ruby

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

Этот код на Ruby отражает одну из описанных выше концепций. Без конкретизации в коде предполагается, что каждый кодек реализует функции encode и decode. Поскольку Ruby — язык с динамической типизацией, любой класс может иметь реализацию этих двух операций и работать как кодек.

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

Фреймворк Ruby on Rails подталкивает к определённым способам организации кода, реализуя архитектуру «Модель-Представление-Контроллер» (MVC).

Go

Обращаясь к языкам со статической типизацией, таким как Go, нам придётся быть более формальными, описывая требуемые типы, но мы всё равно можем создать код, аналогичный приведённому выше.

Тип interface в Go намного мощнее аналогичной конструкции в Java, так как его определение никак не связано с реализацией, и наоборот. Можно даже присвоить каждому кодеку тип ReadWriter и использовать в таком виде.

С

На C тоже можно создать код с аналогичным поведением, но будут некоторые отличия.

Примечание Код создан по примеру размещённого на сайте Computer Science from the Bottom Up.

Сначала в обобщённой структуре мы определяем абстрактные операции (в данном случае функции). Затем мы наполняем их конкретным кодом, например кодером и декодером кодека av1.

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

Linux kernel и концепция «всё — файл»

Концепция «всё — файл» ОС Linux позволяет использовать один интерфейс для работы с любыми ресурсами системы. Например, Linux обрабатывает сетевые сокеты, особые файлы (такие как /proc/cpuinfo) и даже USB-устройства как файлы.

Этот подход облегчает разработку программ для ОС, поскольку мы можем использовать хорошо изученный набор операций для абстракции, названной «файлом». Вот как это работает:

Это возможно только потому, что концепция файла (структуры данных и операции) была разработана как один из главных способов взаимодействия подсистем.  Вот участок API-структуры file_operations:

Эта структура чётко определяет то, что мы подразумеваем под концепцией файла, и какое поведение мы от него ожидаем:

Здесь можно увидеть набор функций, реализующих это поведение, в файловой системе ext4.

Даже файлы cpuinfo proc реализованы через эту абстракцию. Фактически, работая с файлами под Linux, вы используете виртуальную файловую систему (VFS), которая в свою очередь обращается к функциям абстракции.

FFmpeg — форматы

Вот общая схема архитектуры процессов FFmpeg, демонстрирующая, что внутренние компоненты связаны в основном через такие абстрактные концепции, как AVCodec, а не напрямую через конкретные кодеки.

Для входящих файлов в FFmpeg создаётся структура AVInputFormat, реализуемая любым форматом (видеоконтейнером), который требуется использовать. Файлы MKV также заполняют эту структуру своей реализацией, как и формат MP4 — своей.

Такой дизайн позволяет легко интегрировать новые кодеки, форматы и протоколы. В мае 2019 года в FFmpeg был включён кодек DAV1d (аналог av1 с открытым исходным кодом), и, изучив изменения в коде, вы увидите, насколько безболезненно прошло внедрение. В итоге ему только требуется зарегистрироваться в качестве доступного кодека и придерживаться списка общих операций.

Безотносительно используемого нами языка мы всегда можем как минимум попытаться создать код со слабой зависимостью и высокой согласованностью. Именно эти два основных свойства позволят вам писать ПО, которое легко расширять и поддерживать.

Конкурентность — это выполнение задач за определённое время (например, есть 5 процессов и все они в сумме выполняются в течение 60 минут по очереди). Важная деталь заключается в том, что задачи необязательно выполняются одновременно, поэтому их можно разделить на более мелкие и чередующиеся.

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

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

Параллелизм — это выполнение задач в одно и то же время (например, есть 5 задач, каждая из них выполняется в течение 60 минут). Само название подразумевает, что они выполняются параллельно.

Вернёмся на кухню: теперь у нас есть два шеф-повара. Один следит за духовкой, а второй нарезает лук. Работа разделена, так как теперь на кухне трудятся два повара.

Параллелизм — подкласс конкурентности: перед выполнением нескольких одновременных задач вам нужно их сначала правильно организовать.

Что ещё можно почитать на эту тему:

1. Сакральное искусство параллельного и конкурентного программирования.
2. Параллелизм vs. Конкурентность.
3. Основные принципы программирования: конкурентность.

Примечание Вы читаете улучшенную версию некогда выпущенной нами статьи.

1. Набор инструментов для программирования с нуля
2. Переменные
3. Объекты
4. Массивы
5. API
6. Функции
7. Логические ветви и сравнения
8. Циклы
9. null и undefined
10. Области применения
11. Комментирование кода
12. Заключение

Набор инструментов для программирования с нуля

Инструментарий типичного программиста чаще всего состоит из следующих вещей:

• компьютер;
• интернет (прежде всего он нужен для поиска всего неизученного и неизвестного в любом из известных поисковых сервисов);
• редактор кода (или IDE — комплекс программных средств, используемый программистами для разработки программного обеспечения), который поможет упорядочить всё, что вы создаёте;
• компилятор или интерпретатор. Это программа, которая читает ваш код и пытается найти в нём ошибки. Затем он собирает ваш код в единый пакет и передаёт компьютеру для выполнения;
• наушники. Возможно, вас будут отвлекать внешние шумы, а наушники — один из простых способов оградить себя от шумов.

Вы можете использовать бесплатное ПО в начале работы, такое как Atom и Notepad++. Также можно попробовать SublimeText, однако этот редактор является платным.

Переменные

В начале программирования нужно освоить переменные — именованные области памяти для хранения данных. Есть две основные причины, по которым следует именовать данные:

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

Примечание В названиях переменных нельзя использовать апострофы.

Чтобы переменная существовала, её нужно объявить. Объявление переменных служит в роли свидетельства о «рождении» для данных. Давайте посмотрим на пример:

Ключевое слово varозначает переменную.

Переменной нужно присвоить значение:

Теперь вы можете использовать переменную, the_number_of_days_in_december вместо числа 31.

Следует помнить, что вы также можете объявлять переменные для данных, которые ещё не существуют. Например, вы можете объявитьvar donalds_birthdayи сообщить приложению, чтобы оно ожидало ввода значения. Всё, что будет введено пользователем для этой переменной, будет использоваться в тексте под именемdonalds_birthday

Переменной также можно объявить целую строку или фрагмент текста:

Теперь можно где угодно в коде написатьgreat_song_lyricsи компьютер поймёт, что речь идёт о 'pasito a pasito, suave suavecito'. Проверим это утверждение.

Откройте консоль в Google Chrome нажатием клавиши F12 (для владельцев Mac рекомендуется ознакомиться с этой статьёй). Перед вами появится следующее окно:

Убедитесь, что выбрана вкладка «Console», кликните на пустом поле рядом со знаком «больше» (>), объявите переменную и присвойте ей значение, а затем нажмите клавишу ввода.

В консоли отображается сообщение undefined из-за того, что строка кода не вывела какие-либо данные, чего, собственно, делать и не должна. Теперь введите название своей переменной в строку и нажмите кнопку ввода.

Поздравляем! Консоль (которая также служит в роли интерпретатора) понимает вашу переменную.

Объекты

А что такое разработка без объектов? В JavaScript объекты объявляются почти так же, как и переменные:

Здесь мы объявили четыре переменные, и сможем найти их, поэтому мы сможем найти их, когда захотим узнать что-нибудь о human. Всё, что вы видите в фигурных скобках, разграничивается на две части: слева прописываются поля, а справа указываются свойства для них. Объект может иметь любые свойства до тех пор, пока они находятся внутри {фигурных скобок}.

Мы можем использовать объект humanи ссылаться на него точно так же, как и на любую другую переменную. Компьютер поймёт, что нужно сослаться на какое-либо определённое свойство, если мы его напишем через точку:

Каждый из элементов сверху может быть изменён и ссылаться на другое свойство. Например, давайте изменим имя (name):

Массивы

Чтобы начать программировать, нужно изучить и массивы — списки похожих фрагментов данных. В программировании на JavaScript массивы выглядят следующим образом:

Для массивов принято использовать [квадратные скобки]. В данном случае вы можете использовать tweets в любом месте вашего кода, ссылаясь на массив, который только что определили.

Примечание Счёт массивов начинается с нуля, а не с единицы.

Если вы хотите обратиться к какому-то отдельному элементу, то можно сделать следующее:

tweets[0]

tweets[1]

tweets[2]

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

Каждое из приведённых выше выражений — переменная. Вы можете присвоить им какое-нибудь новое значение, чтобы поэкспериментировать:

Теперь tweets[2] будет ссылаться на новое значение.

Массивы могут содержать текст, числа, даты, объекты и даже другие массивы. Массивы также могут быть свойствами объектов.

Чтобы обратиться к message, вы можете написать следующее:

И компьютер поймёт, что вы имеете в виду ‘Blink twice if you need help’

API

API — набор свойств и методов (целевых фрагментов кода), которые имеют свои имена, как переменные.

Массивы JavaScript также имеют свой собственный API. Свойство length является частью этого API. Другая его часть — метод push, который добавляет элементы в конец массива:

Метод похож на свойство, потому что к нему можно получить доступ через точку. Он отличается от свойства тем, что после него нужно поставить (круглые скобки). В этих круглых скобках хранятся данные, которые мы хотим добавить в наш массив. Теперь в tweets четыре элемента. Это выглядит вот так:

Функции

Функция — это фрагмент кода, который что-то выполняет и имеет имя. Функции можно легко объявлять:

Объявление функции начинается с ключевого слова, затем ей даётся имя. return заставляет значение «выпрыгивать» из функции. Затем функция завершается (если вы напишете код после return, то он не будет выполнен). Таким образом, вы можете сделать следующее:

Мы объявляем переменную с именем the_loneliest_number. Часть нашей команды вызывает функцию giveMeOne() и так как функция говорит return 1, выводится единица. Наша переменная будет содержать цифру 1. Теперь попробуйте ввести в браузере первый блок с функцией, затем блок с переменной, а затем ввести the_loneliest_number и нажать кнопку ввода. Вы увидите единицу.

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

Часть данных, которую мы добавляем в функции, называется аргументом. Объявление функции, которая может ожидать аргументы, выглядит так:

Оператор return складывает аргументы number1и number2, а затем выдаёт результат.

В JavaScript также можно писать математические выражения как на калькуляторах:

• +используется для сложения;
• -используется для вычитания;
• (круглые скобки) служат для принудительного выполнения порядка операций;
• *используется для умножения;
• % используется для получения остатка деления.

Вы могли бы записать предыдущую функцию таким образом:

Эта функция делает всё то же, что и предыдущая, только в неё введена переменная в качестве посредника.

Логические ветви и сравнения

Предположим, мы пишем приложение, которое определяет, разрешено ли конкретному человеку войти в ночной клуб. Представим, что в JavaScript API есть метод, который получает возраст пользователя. Мы назовём его getUserAge(). Также предположим, что существуют два других метода: allowThemInTheNightClub() APIAPIи throwThemOutOnTheirButt(). Как мы можем помочь нашей программе решить, какой из этих двух методов нужно вызвать, исходя из возвращаемого значения первого метода?

Вы уже знаете, что делает первая строка. age (возраст) может варьироваться от 7 до 101. Теперь нам нужно определить больше значение age, чем 21 или нет.

Мы делаем это с помощью оператора if(если) — ключевого слова, похожего на метод. Аргумент, который он ожидает, представляет собой какое-то выражение (обычно сравнение). Сравнения принимают два значения и сравнивают их друг с другом. В результате чего выбирается одно из следующих ключевых слов: true— в случае соответствия правилу и false— в случае несоответствия. Это называется логическим выражением.

В JavaScript есть возможность 6 видов сравнения:
• === сравнивает значения. Если они одинаковы, то вы увидите true. Например, 6 === 6 было бы true;
• !== сравнивает значения на неравенство. Если они не равны, то вы увидите true. Например, 6 !== 3 было бы true;
• > проверяет, больше ли значение слева. Если больше, то вы увидите true. Например, 6 > 3 было бы true;
• < проверяет, больше ли значение справа. Если больше, то вы увидите true. Например, 3 < 6 было бы true;
• >= проверяет, больше или равна правая часть левой. Если больше или равна, то вы увидите true. Например, выражения 6 >= 6и6 >= 5были бы true;
• <= проверяет, меньше или равна правая часть левой. Если больше или равна, то вы увидите true. Например, выражения 6 <= 6 и 6 <= 7 были бы true.

Оператор if оценивает сравнение. Если выводится true, то код выполняется внутри блока сравнения. Если выводится false, код не выполняется и игнорируется.

Оператор if также может работать с оператором else(иначе). Он содержит в себе блок кода, который будет выполнен, если сравнение вернёт false.

Циклы

Но что такое циклы в программировании? Иногда при работе с массивом может понадобиться выполнить какой-то блок кода несколько раз подряд. В таких случаях следует использовать циклы. Простейшим видом цикла JavaScript является while (цикл выполняется, пока условие истинно):

Цикл while использует тот же синтаксис, что и оператор if: нём используются круглые скобки, вы проходите через сравнение и т. д. Но блок ifвыполняет код внутри только один раз, а блок whileповторяется раз за разом. Он выполняет условие до тех пор, пока оно не станет false. Если оно соответствует true, блок запускается снова и снова.

Сколько раз будет выполняться цикл? Что же, в первый раз он оценит сравнение и проверит меньше ли index(который равен 0), чем the_real_slim_shady[0]. Если сравнение выведет true, то будет запущен цикл, так как indexравен нулю. С этого момента цикл будет выполняться до тех пор, пока блок indexне будет равен 4, так как the_real_slim_shady[4] не существует.

null и undefined

Если вы объявите переменную и не присвоите ей значение, то она будет содержать специальное значение undefined. Null значит почти то же самое. Предлагаем почитать, чем они различаются, а также узнать про обработку undefined.

Области применения

Если вы объявите переменную внутри функции, то вы не сможете ею воспользоваться где-нибудь за пределами функции. Пример:

В функции объявлена переменная wildIndiscretions. Мир за пределами функции не знает о существовании переменной. Даже оператор ifне может ничего сделать в этом случае. Оператор ifсработает только внутри функции, если поместить его перед return.

Комментирование кода

Не всегда бывает понятно, что выполняет тот или иной код. Поэтому всегда следует комментировать его. В JavaScript комментарии начинаются с //:

var age = 21{

// переменная равна 21.

// Если она не равна 21, пожалуйста, измените на 21.

// Что сделать: добавить больше переменных.

}

Так что же такое программирование

Программирование — это написание приложений, основанное на определённых правилах, некоторые их которых перечислены в нашей статье.

Теперь вы понимаете, что представляет собой разработка на базовом уровне. Желаем успехов на пути к освоению мастерства программирования. Если же вы понимаете, что JavaScript — не ваше, узнайте, какой язык программирования подойдёт для новичка.

Вы наверняка слышали о таких понятиях, как императивное и декларативное программирование, и скорее всего гуглили определения. И поэтому вы наверняка видели что-то подобное: “Императивное программирование — это описание того, как ты делаешь что-то, а декларативное — того, что ты делаешь. Это объяснение отлично подходит тем, кто уже разобрался в этом вопросе — но не новичкам.

Самым сложным является тот факт, что разница между декларативным и императивным подходами часто понятна интуитивно, но её сложно задать определением. Я общался со многими программистами и пришёл к заключению, что лучшее объяснение — это сочетание метафор и примеров кода. Итак, начнём.

Допустим, вы поняли, что слишком много времени уделяли работе, и решили пригласить свою половинку на свидание. Вы пришли в ресторан, подошли к администратору и сказали…

Императивный подход (как): Я вижу, что тот угловой столик свободен. Мы пойдём туда и сядем там.

Декларативный подход (что): Столик для двоих, пожалуйста.

Императивный подход означает то, как вы займёте место. Вы должны перечислить все шаги этого процесса. Декларативный же подход заявляет, что вам нужен столик на двоих.

Больше метафор!

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

“Я у Ашана. Как мне пройти до твоего дома?”

Императивный ответ:

“Пройди черезсеверный выход парковки и поверни налево. Сядь на автобус 678 и выйди на остановке “Улица Победы”. Поверни направо, как если бы ты шёл в Икею. Иди прямо и поверни направо у первого светофора. На следующем светофоре поверни налево. Номер моего дома — 134.”

Декларативный ответ:

Мой адрес: Энск, улица Победы, дом 134

Неважно, как я попаду к твоему дому, важно, на какой машине я приеду. У неё будет или императивная механическая КПП, или декларативная автоматическая КПП. Достаточно метафор?

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

Итак, я повторюсь: многие (если не все) декларативные подходы имеют слой неких императивных абстракций.

Теперь мы перейдём от приятных метафор к реальному коду. Сперва посмотрим, какие языки являются декларативными, а какие — императивными:

• Императивные: C, C++, Java.
• Декларативные: SQL, HTML.
• Смешанные (могут быть таковыми): JavaScript, C#, Python.

Вот типичные примеры на SQL и HTML:

Достаточно взглянуть на них, чтобы понять, что происходит. Они декларативны, заявляя, что должно быть сделано, а не как. Вы описываете желаемый результат, не углубляясь в инструкции. Неважно, как будут выбраны пользователи из Мексики. Неважно, как браузер распарсит ваш article. Важно, что вы получите мексиканских пользователей и новый header и paragraph на сайте.

Пока неплохо. Давайте рассмотрим примеры на JavaScript.

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

1. Напишите функцию, называющуюся double, которая принимает массив чисел и возвращает новый массив, каждый элемент которого в два раза больше входного: double([1,2,3]) -> [2,4,6].
2. Напишите функцию, называющуюся add, которая принимает массив и возвращает сумму всех его элементов: add([1,2,3]) -> 6.
3. Используя jQuery (или чистый JavaScript), добавьте обработчик события click к элементу с id, равным btn. По нажатию переключите класс highlight и смените текст на Add Highlight или Remove Highlight, в зависимости от текущего состояния элемента.

Давайте взглянем на самые распространённые подходы к решению этих задач, которые являются императивными.

Разобравшись, что общего у этих императивных примеров, мы поймём, что именно делает их императивными.

1. Очевидно, что все они описывают, как решить проблему: мы явно указываем все шаги.
2. Это уже не так очевидно для тех, кто не привык думать декларативно, или даже функционально. В каждом примере происходит изменение какого-либо состояния. В первых двух примерах происходило изменение переменной results, а в третьей состояние было в самой DOM — и его мы тоже изменяли.
3. Это уже субъективно, но я считаю, что код выше нечитаем. Я не могу с первого взгляда понять, что происходит — вместо этого мне приходится читать код построчно.

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

Гораздо лучше ?

Заметьте, что в первых двух примерах я использовал встроенные методы JavaScript, map и reduce. Как видите, декларативные решения вновь оказались абстракциями над императивными реализациями. Но нас не интересует, как реализованы эти методы. Мы также не изменяем состояния, да и читается этот код лучше.

Ну а третий? В нём я немного схитрил, использовав React — но обратите внимание, что все три императивные ошибки исправлены. React замечателен тем, что в нём вы можете создавать декларативные пользовательские интерфейсы. Смотря на компонент Btn, сразу понятно, как будет выглядеть интерфейс. Кроме того, состояния «живут» не в DOM, а в самом React-компоненте.

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

Если вы такой же разработчик, как и я, то наверняка сперва изучали парадигму ООП. Первым вашим яыком были Java или C++ — или, если вам повезло, Ruby, Python или C# — поэтому вы наверняка знаете, что такое классы, объекты, экземпляры и т.д. В чём вы точно не особо разбираетесь, так это в основах той странной парадигмы, называющейся функциональным программированием, которая существенно отличается не только от ООП, но и от процедурного, прототипно-ориентированного и других видов программирования.

Функциональное программирование становится популярным — и на то есть причины. Сама парадигма не нова: Haskell, пожалуй, является самым функциональным языком, а возник он в 90-ых. Такие языки, как Erlang, Scala, Clojure также попадают под определение функциональных. Одним из основных преимуществ функционального программирования является возможность написания программ, работающих конкурентно (если вы уже забыли, что это — освежите память прочтением статьи о конкурентности), причём без ошибок — то есть взаимные блокировки и потокобезопасность вас не побеспокоят.

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

Вступление: Все эти принципы не обязательны (многие языки следуют им не полностью). Все они теоретические и нужны для наиболее точного определения функциональной парадигмы.

1. Все функции — чистые

Это правило безусловно является основным в функциональном программировании. Все функции являются чистыми, если они удовлетворяют двум условиям:

1. Функция, вызываемая от одних и тех же аргументов, всегда возвращает одинаковое значение.
2. Во время выполнения функции не возникают побочные эффекты.

Первое правило понятно — если я вызываю функцию sum(2, 3), то ожидаю, что результат всегда будет равен 5. Как только вы вызываете функцию rand(), или обращаетесь к переменной, не определённой в функции, чистота функции нарушается, а это в функциональном программировании недопустимо.

Второе правило — никаких побочных эффектов — является более широким по своей природе. Побочный эффект — это изменение чего-то отличного от функции, которая исполняется в текущий момент. Изменение переменной вне функции, вывод в консоль, вызов исключения, чтение данных из файла — всё это примеры побочных эффектов, которые лишают функцию чистоты. Может показаться, что это серьёзное ограничение, но подумайте ещё раз. Если вы уверены, что вызов функции не изменит ничего “снаружи”, то вы можете использовать эту функцию в любом сценарии. Это открывает дорогу конкурентному программированию и многопоточным приложениям.

2. Все функции — первого класса и высшего порядка

Эта концепция — не особенность ФП (она используется в Javascript, PHP и других языках) — но его обязательное требование. На самом деле, на Википедии есть целая статья, посвящённая функциям первого класса. Для того, чтобы функция была первоклассной, у неё должна быть возможность быть объявленной в виде переменной. Это позволяет управлять функцией как обычным типом данных и в то же время исполнять её.

Функции высшего порядка же определяются как функции, принимающие другую функцию как аргумент или возвращающие функцию. Типичными примерами таких функций являются map и filter.

3. Переменные неизменяемы

Тут всё просто. В функциональном программировании вы не можете изменить переменную после её инициализации. Вы можете создавать новые, но не можете изменять существующие — и благодаря этому вы можете быть уверены, что никакая переменная не изменится.

4. Относительная прозрачность функций

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

Пусть у нас есть Java-функция, которая складывает 3 и 5:

Очевидно, что любой вызов этой функции можно заменить на 8 — значит, функция относительно прозрачна. Вот пример непрозрачной функции:

Эта функция ничего не возвращает, но печатает текст, и при замене вызова функции на ничто состояние консоли будет другим — значит, функция не является относительно прозрачной.

5. Функциональное программирование основано на лямбда-исчислении

Функциональное программирование сильно опирается на математическую систему, называющуюся лямбда-исчислением. Я не математик, поэтому я не буду углубляться в детали — но я хочу обратить внимание на два ключевых принципа лямбда-исчисления, которые формируют самое понятие функционального программирования:

1. В лямбда-исчислении все функции могут быть анонимными, поскольку единственная значимая часть заголовка функции — это список аргументов.
2. При вызове все функции проходят процесс каррирования. Он заключается в следующем: если вызывается функция с несколькими аргументами, то сперва она будет выполнена лишь с первым аргументом и вернёт новую функцию, содержащую на 1 аргумент меньше, которая будет немедленно вызвана. Этот процесс рекурсивен и продолжается до тех пор, пока не будут применены все аргументы, возвращая финальный результат. Поскольку функции являются чистыми, это работает.

Как я уже говорил, лямбда-исчисление на этом не заканчивается — но мы рассмотрели лишь ключевые аспекты, связанные с ФП. Теперь, в разговоре о функциональном программировании вы сможете блеснуть словечком “лямбда-исчисление”, и все подумают, что вы шарите 🙂

Заключение

Функциональное программирование серьёзно напрягает мозги — но это очень мощный подход, и я считаю, что его популярность будет только расти.

Если вы хотите узнать о функциональном программировании побольше, то советуем вам ознакомиться с примерами использования принципов ФП в JavaScript (часть 1, часть 2), а также с циклом статей, посвящённым функциональному C#.

Часто во время работы программы нам бывает нужна информация о данных — например, какой у них тип или являются ли они экземпляром класса (в ООП). Опираясь на эти знания, нам нужно проводить над данными некоторые операции, или даже изменять их — но необходимого вида данных у нас может и не быть! Если вы ничего не поняли, не расстраивайтесь — мы подробно во всём разберёмся. Всё, что я здесь описал — это иллюстрация целей двух возможностей, присутствующих почти в каждом современном языке программирования: интроспекции и рефлексии.

Интроспекция

Интроспекция — это способность программы исследовать тип или свойства объекта во время работы программы. Как мы уже упоминали, вы можете поинтересоваться, каков тип объекта, является ли он экземпляром класса. Некоторые языки даже позволяют узнать иерархию наследования объекта. Возможность интроспекции есть в таких языках, как Ruby, Java, PHP, Python, C++ и других. В целом, инстроспекция — это очень простое и очень мощное явление. Вот несколько примеров использования инстроспекции:

В Python самой распространённой формой интроспекции является использование метода dir для вывода списка атрибутов объекта:

В Ruby интроспекция очень полезна — в частности из-за того, как устроен сам язык. В нём всё является объектами — даже класс — и это приводит к интересным возможностям в плане наследования и рефлексии (об этом ниже). Если вы хотите узнать об этом больше, советую прочитать мини-цикл Metaprogramming in Ruby.

Прим. перев. Также не будет лишним прочитать нашу статью, посвящённую интроспекции в Ruby.

Вот несколько простых примеров интроспекции с использованием IRB (Interactive Ruby Shell):

Вы также можете узнать у объекта, экземпляром какого класса он является, и даже “сравнить” классы.

Однако интроспекция — это не рефлексия; рефлексия позволяет нам использовать ключевые принципы интроспекции и делать действительно мощные вещи с нашим кодом.

Рефлексия

Интроспекция позволяет вам изучать атрибуты объекта во время выполнения программы, а рефлексия — манипулировать ими. Рефлексия — это способность компьютерной программы изучать и модифицировать свою структуру и поведение (значения, мета-данные, свойства и функции) во время выполнения. Простым языком: она позволяет вам вызывать методы объектов, создавать новые объекты, модифицировать их, даже не зная имён интерфейсов, полей, методов во время компиляции. Из-за такой природы рефлексии её труднее реализовать в статически типизированных языках, поскольку ошибки типизации возникают во время компиляции, а не исполнения программы (подробнее об этом здесь). Тем не менее, она возможна, ведь такие языки, как Java, C# и другие допускают использование как интроспекции, так и рефлексии (но не C++, он позволяет использовать лишь интроспекцию).

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

Мне кажется, что мы сказали много об определении рефлексии, но смысла это пока несёт мало. Давайте взглянем на примеры кода ниже (с рефлексией и без), каждый из которых создаёт объект класса Foo и вызывает метод hello.

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

Eval-выражения

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

Рассмотрим следующий пример кода на Python, который принимает данные из стороннего источника в Сети (это одна из причин, по которой люди пользуются eval-выражениями):

Защита программы будет нарушена, если кто-то передаст в метод get_data() такую строку:

Для безопасного использования eval-утверждений нужно сильно ограничивать формат входных данных — и обычно это лишь занимает лишнее время.

Заключение

Интроспекция и рефлексия — это очень мощные инструменты современных языков, и их понимание может позволить вам писать по-настоящему крутой код. Ещё раз отметим: интроспекция — это изучение атрибутов объекта, а рефлексия — это манипуляция ими. Будьте внимательны при использовании рефлексии, поскольку она может сделать ваш код нечитаемым и уязвимым. Чем больше сила, тем больше и ответственность — вот девиз всего, что связано с метапрограммированием.

Когда вы изучаете языки программирования, то в разговорах часто слышите фразы наподобие “статически типизированный” или “динамически типизированный”. Эти понятия описывают процесс проверки соответствия типов, и как статическая проверка типов, так и динамическая, относятся к разным системам типов. Система типов — это набор правил, которые присваивают свойство, называющееся “тип”, различным сущностям в программе: переменным, выражениям, функциям или модулями — с конечной целью уменьшения количества ошибок путём подтверждения того, что данные отображаются корректно.

Не волнуйтесь, я знаю, что это всё звучит запутанно, поэтому мы начнём с основ. Что такое “проверка соответствия типов” и что такое вообще тип?

Тип

Тип, также известный как тип данных, это вид классификации, отмечающий одних из различных видов данных. Я не люблю использовать слово “тип” в этом смысле, поэтому скажем так: тип описывает возможные значения структуры (например, переменной), её семантическое значение и способ хранения в памяти. Если это звучит непонятно, подумайте о целых, строках, числах с плавающей запятой и булевых величинах — это всё типы. Типы можно разбить на категории:

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

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

Проверка соответствия типов

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

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

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

Теперь, когда мы знаем, что такое типы и как работает проверка соответствия типов, рассмотрим два основных вида проверки: статическую и динамическую.

Статическая проверка типов

Язык обладает статической типизацией, если тип переменной известен во время компиляции, а не выполнения. Типичными примерами таких языков являются Ada, C, C++, C#, JADE, Java, Fortran, Haskell, ML, Pascal, и Scala.

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

Динамическая проверка типов

Динамическая проверка типов — это процесс подтверждения типобезопасности программы во время её выполнения. Типичными примерами динамически типизированных языков являются Groovy, JavaScript, Lisp, Lua, Objective-C, PHP, Prolog, Python, Ruby, Smalltalk и Tcl.

Большая часть типобезопасных языков в той или иной мере использует динамическую проверку типов, даже если основным инструментом является статическая. Так происходит из-за того, что многие свойства невозможно проверить статически. Предположим, что программа определяет два типа, A и B, где B — подтип A. Если программа пытается преобразовать тип A в тип B, т.е. произвести понижающее приведение, то эта операция будет одобрена лишь в том случае, когда значение на самом деле имеет тип B. Поэтому для подтверждения безопасности операции нужна динамическая проверка типов.

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

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

Типичные заблуждения

Миф 1: статическая / динамическая типизация ==  сильная / слабая типизация

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

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

Мы часто ассоциируем статически типизированные языки, такие как Java и C#, с сильно типизированным (они такими и являются), поскольку тип данных задаётся явно при инициализации переменной — как в этом примере на Java:

Тем не менее, Ruby, Python и JavaScript (все они обладaют динамической типизацией) также являются сильно типизированными, хотя разработчику и не нужно указывать тип переменной при объявлении. Рассмотрим такой же пример, но написанный на Ruby:

Оба языка являются сильно типизированными, но используют разные методы проверки типов. Такие языки, как Ruby, Python и JavaScript не требуют явного определения типов из-за вывода типов — способности программно выводить нужный тип переменной в зависимости от её значения. Вывод типов — это отдельное свойство языка, и не относится к системам типов.

Слабо типизированный язык — это язык, в котором переменные не привязаны к конкретному типу данных; у них всё ещё есть тип, но ограничения типобезопасности гораздо слабее. Рассмотрим следующий пример кода на PHP:

Поскольку PHP обладает слабой типизацией, ошибки в этом коде нет. Аналогично предыдущему предположению, не все слабо типизированные языки являются динамически типизированными: PHP — это динамически типизированный язык, но вот C — тоже язык со слабой типизацией — воистину статически типизирован.

Миф разрушен.

Хотя статическая / динамическая  и сильная / слабая системы типов и являются разными, они обе связаны с типобезопасностью. Проще всего это выразить так: первая система говорит о том, когда проверяется типобезопасность, а вторая — как.

Миф 2: статическая / динамическая типизация == компилируемые / интерпретируемые языки

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

Когда мы говорим о типизации языка, мы говорим о языке как о целом. Например, неважно, какую версию Java вы используете — она всегда будет статически типизированной. Это отличается от того случая, когда язык является компилируемым или интерпретируемым, поскольку в этом случае мы говорим о конкретной реализации языка. В теории, любой язык может быть как компилируемым, так и интерпретируемым. Самая популярная реализация языка Java использует компиляцию в байткод, который интерпретирует JVM — но есть и иные реализации этого языка, которые компилируются напрямую в машинный код или интерпретируются как есть.

Если это всё ещё непонятно, советую прочесть одну из предыдущих статей этого цикла.

Заключение

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

Нет однозначного ответа на вопрос “какая типизация лучше?” — у каждой есть свои преимущества и недостатки. Некоторые языки — такие как Perl и C# — даже позволяют вам самостоятельно выбирать между статической и динамической системами проверки типов. Понимание этих систем позволит вам лучше понять природу возникающих ошибок, а также упростит борьбу с ними.

В третьей статье цикла “Принципы программирования” мы поговорим о конкурентности (concurrency). Конкурентность — это свойство систем (программы, сети, компьютера и т.д.), допускающее одновременное выполнение нескольких вычислительных процессов, которые могут взаимодействовать друг с другом. Вычисления запускаются, проходят и завершаются в пересекающихся промежутках времени; они также могут происходить абсолютно одновременно (параллелизм), но это не обязательно.

Конкурентность в программировании

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

Конкурентные и параллельные вычисления

Хотя и считается, что конкурентные вычисления включают в себя параллельные, у них есть существенные отличия.

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

Зачем нужно конкурентное программирование?

Главным преимуществом этого подхода является максимально возможное использование ресурсов системы. В начале 2000-ых стало популярным использование многоядерных процессоров, пришедших на смену одноядерным, пускай и с очень мощным на то время ядром. Это в первую очередь позволяет оптимизировать время выполнения программы путём разделения нагрузки на ядра.  Я не буду углубляться в эту тему — принципы синхронизации процессов и потоков различны в разных ОС — но вы можете почитать об этом, например, здесь.

В современных языках программирования принцип конкурентности обычно реализован в виде процесса многопоточности. Многопоточность позволяет программе работать в нескольких потоках, предоставляя преимущества параллелизации (быстрое исполнение, эффективное использование ресурсов и т.д.), но она также сохраняет и её недостатки (о них ниже), поэтому некоторые языки используют механизм, названный Global Interpreter Lock (GIL). Обычно его можно встретить в стандартных реализациях Python и Ruby (CPython и Ruby MRI соответственно), он предотвращает одновременное исполнение более чем одного потока — даже на многоядерных процессорах. Это похоже на недостаток, но GIL нужен для предотвращения потоконебезопасных активностей. Реализации с GIL обычно повышают скорость работы однопоточных программ и облегчают интеграцию с библиотеками C, но за это приходится платить возможностями многопоточности.

Проблемы конкурентного программирования

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

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

Прим. перев. Рекомендуем также почитать наши материалы по теме многопоточного программирования:

• Безопасность потоков в С++;
• Обработка исключений в многопоточных приложениях;
• Задача с разбором решения: “Разработайте класс, обеспечивающий блокировку так, чтобы предотвратить возникновение мертвой блокировки”.

Будущее конкурентного программирования

Конкурентное программирование — это очень мощный инструмент, даже с учётом его недостатков. Несколько языков предоставляют феноменальную поддержку инструментов для использования этого принципа: больше всего это проявляется в API языка Go, созданного в Google. Разработчики других языков, например, Python и Ruby, видят отрицательные стороны конкурентности и поэтому используют GIL по умолчанию. Так или иначе, если вы пишете приложение, которое использует принципы конкурентности, обязательно уделите особое внимание планированию, иначе вы рискуете повредить данные.

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

Будучи разработчиками, мы часто сталкиваемся с такими понятиями, как компилятор и интерпретатор, но я считаю, что многие не совсем понимают, что они означают. Между тем, компиляция и интерпретация — это основы работы всех языков программирования. Давайте взглянем на то, как на самом деле устроены эти понятия.

Вступление

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

Компилируемый язык — это такой язык, что программа, будучи скомпилированной, содержит инструкции целевой машины; этот машинный код непонятен людям. Интерпретируемый же язык — это такой, в котором инструкции не исполняются целевой машиной, а считываются и исполняются другой программой (которая обычно написана на языке целевой машины). Как у компиляции, так и у интерпретации есть свои плюсы и минусы, и именно это мы и обсудим.

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

Компилируемые языки

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

Низкоуровневые языки как правило являются компилируемыми, поскольку эффективность обычно ставится выше кроссплатформенности. Кроме того, компилируемые языки дают разработчику гораздо больше возможностей в плане контроля аппаратного обеспечения, например, управления памятью и использованием процессора. Примерами компилируемых языков являются C, C++, Erlang, Haskell и более современные языки, такие как Rust и Go.

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

Интерпретируемые языки

В отличие от компилируемых языков, интерпретируемым для исполнения программы не нужен машинный код; вместо этого программу построчно исполнят интерпретаторы. Раньше процесс интерпретации занимал очень много времени, но с приходом таких технологий, как JIT-компиляция, разрыв между компилируемыми и интерпретируемыми языками сокращается. Примерами интерпретируемых языков являются PHP, Perl, Ruby и Python. Вот некоторые из концептов, которые стали проще благодаря интерпретируемым языкам:

• Независимость от платформы;
• Рефлексия;
• Динамическая типизация;
• Меньший размер исполняемых файлов:
• Динамические области видимости.

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

Бонус: байткод-языки

Байткод-языки — это такие языки, которые используют для исполнения кода как компиляцию, так и интерпретацию. Java и фреймворк .NET — это типичные примеры байткод-языков. На самом деле, Java Virtual Machine (JVM) — это настолько популярная виртуальная машина для интерпретации байткода, что на ней работают реализации нескольких языков. Кстати, недавно стало известно, что в новой версии Java будет также поддерживаться и статическая компиляция.

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

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

Заключение

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

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

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

Рассказывает Аарон Краус

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

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

Стек

Стек — это область оперативной памяти, которая создаётся для каждого потока. Он работает в порядке LIFO (Last In, First Out), то есть последний добавленный в стек кусок памяти будет первым в очереди на вывод из стека. Каждый раз, когда функция объявляет новую переменную, она добавляется в стек, а когда эта переменная пропадает из области видимости (например, когда функция заканчивается), она автоматически удаляется из стека. Когда стековая переменная освобождается, эта область памяти становится доступной для других стековых переменных.

Из-за такой природы стека управление памятью оказывается весьма логичным и простым для выполнения на ЦП; это приводит к высокой скорости, в особенности потому, что время цикла обновления байта стека очень мало, т.е. этот байт скорее всего привязан к кэшу процессора. Тем не менее, у такой строгой формы управления есть и недостатки. Размер стека — это фиксированная величина, и превышение лимита выделенной на стеке памяти приведёт к переполнению стека. Размер задаётся при создании потока, и у каждой переменной есть максимальный размер, зависящий от типа данных. Это позволяет ограничивать размер некоторых переменных (например, целочисленных), и вынуждает заранее объявлять размер более сложных типов данных (например, массивов), поскольку стек не позволит им изменить его. Кроме того, переменные, расположенные на стеке, всегда являются локальными.

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

Куча

Куча — это хранилище памяти, также расположенное в ОЗУ, которое допускает динамическое выделение памяти и не работает по принципу стека: это просто склад для ваших переменных. Когда вы выделяете в куче участок памяти для хранения переменной, к ней можно обратиться не только в потоке, но и во всем приложении. Именно так определяются глобальные переменные. По завершении приложения все выделенные участки памяти освобождаются. Размер кучи задаётся при запуске приложения, но, в отличие от стека, он ограничен лишь физически, и это позволяет создавать динамические переменные.

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

В сравнении со стеком, куча работает медленнее, поскольку переменные разбросаны по памяти, а не сидят на верхушке стека. Некорректное управление памятью в куче приводит к замедлению её работы; тем не менее, это не уменьшает её важности — если вам нужно работать с динамическими или глобальными переменными, пользуйтесь кучей.

Сравнение стека и кучи

Параметр | Стек (Stack) | Куча (Heap)
Принцип работы | LIFO (последний пришёл — первый ушёл) | Произвольный доступ через указатели
Скорость | Очень высокая (управляется ЦП) | Ниже (управляется программой или GC)
Размер | Фиксированный, задаётся при создании потока | Ограничен только физической памятью
Область видимости | Локальные переменные | Глобальные и динамические переменные
Управление | Автоматическое (ЦП) | Ручное (программист) или сборщик мусора
Риски | Переполнение стека (stack overflow) | Утечки и фрагментация памяти
Применение | Вызовы функций, локальные переменные | Динамические структуры, объекты, массивы

Заключение

Вот вы и познакомились с понятиями стека и кучи. Вкратце, стек — это очень быстрое хранилище памяти, работающее по принципу LIFO и управляемое процессором. Но эти преимущества приводят к ограниченному размеру стека и специальному способу получения значений. Для того, чтобы избежать этих ограничений, можно пользоваться кучей — она позволяет создавать динамические и глобальные переменные — но управлять памятью должен либо сборщик мусора, либо сам программист, да и работает куча медленнее.

Часто задаваемые вопросы

Что произойдёт, если стек переполнится?

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

Зачем нужна куча, если стек быстрее?

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

Как сборщик мусора связан с кучей?

Сборщик мусора (garbage collector) автоматически отслеживает объекты в куче и освобождает память, которая больше не используется. Он есть в языках вроде Java, Python, Go и C#. В языках без сборщика мусора (C, C++) программист обязан вручную вызывать free() или delete для освобождения памяти.

В каких языках программист должен управлять памятью вручную?

В C и C++ программист сам отвечает за выделение и освобождение памяти в куче (malloc/free, new/delete). Rust использует уникальный подход — систему владения (ownership), которая позволяет управлять памятью без сборщика мусора и без ручного освобождения.